def test_distributed_tracing_policy_badurl(caplog): """Test policy with a bad url that will throw, and be sure policy ignores it""" with ContextHelper(): exporter = MockExporter() trace = tracer_module.Tracer(sampler=AlwaysOnSampler(), exporter=exporter) with trace.span("parent"): policy = DistributedTracingPolicy() request = HttpRequest("GET", "http://[[[") request.headers["x-ms-client-request-id"] = "some client request id" pipeline_request = PipelineRequest(request, PipelineContext(None)) with caplog.at_level(logging.WARNING, logger="azure.core.pipeline.policies.distributed_tracing"): policy.on_request(pipeline_request) assert "Unable to start network span" in caplog.text response = HttpResponse(request, None) response.headers = request.headers response.status_code = 202 response.headers["x-ms-request-id"] = "some request id" ctx = trace.span_context header = trace.propagator.to_headers(ctx) assert request.headers.get("traceparent") is None # Got not network trace policy.on_response(pipeline_request, PipelineResponse(request, response, PipelineContext(None))) time.sleep(0.001) policy.on_request(pipeline_request) policy.on_exception(pipeline_request) trace.finish() exporter.build_tree() parent = exporter.root assert len(parent.children) == 0
def test_distributed_tracing_policy_badurl(caplog): """Test policy with a bad url that will throw, and be sure policy ignores it""" settings.tracing_implementation.set_value(FakeSpan) with FakeSpan(name="parent") as root_span: policy = DistributedTracingPolicy() request = HttpRequest("GET", "http://[[[") request.headers["x-ms-client-request-id"] = "some client request id" pipeline_request = PipelineRequest(request, PipelineContext(None)) with caplog.at_level(logging.WARNING, logger="azure.core.pipeline.policies.distributed_tracing"): policy.on_request(pipeline_request) assert "Unable to start network span" in caplog.text response = HttpResponse(request, None) response.headers = request.headers response.status_code = 202 response.headers["x-ms-request-id"] = "some request id" assert request.headers.get("traceparent") is None # Got not network trace policy.on_response(pipeline_request, PipelineResponse(request, response, PipelineContext(None))) time.sleep(0.001) policy.on_request(pipeline_request) try: raise ValueError("Transport trouble") except: policy.on_exception(pipeline_request) assert len(root_span.children) == 0
def test_distributed_tracing_policy_with_user_agent(): """Test policy working with user agent.""" settings.tracing_implementation.set_value(FakeSpan) with mock.patch.dict('os.environ', {"AZURE_HTTP_USER_AGENT": "mytools"}): with FakeSpan(name="parent") as root_span: policy = DistributedTracingPolicy() request = HttpRequest("GET", "http://localhost") request.headers["x-ms-client-request-id"] = "some client request id" pipeline_request = PipelineRequest(request, PipelineContext(None)) user_agent = UserAgentPolicy() user_agent.on_request(pipeline_request) policy.on_request(pipeline_request) response = HttpResponse(request, None) response.headers = request.headers response.status_code = 202 response.headers["x-ms-request-id"] = "some request id" pipeline_response = PipelineResponse(request, response, PipelineContext(None)) assert request.headers.get("traceparent") == '123456789' policy.on_response(pipeline_request, pipeline_response) time.sleep(0.001) policy.on_request(pipeline_request) try: raise ValueError("Transport trouble") except: policy.on_exception(pipeline_request) user_agent.on_response(pipeline_request, pipeline_response) network_span = root_span.children[0] assert network_span.name == "/" assert network_span.attributes.get("http.method") == "GET" assert network_span.attributes.get("component") == "http" assert network_span.attributes.get("http.url") == "http://localhost" assert network_span.attributes.get("http.user_agent").endswith("mytools") assert network_span.attributes.get("x-ms-request-id") == "some request id" assert network_span.attributes.get("x-ms-client-request-id") == "some client request id" assert network_span.attributes.get("http.status_code") == 202 network_span = root_span.children[1] assert network_span.name == "/" assert network_span.attributes.get("http.method") == "GET" assert network_span.attributes.get("component") == "http" assert network_span.attributes.get("http.url") == "http://localhost" assert network_span.attributes.get("http.user_agent").endswith("mytools") assert network_span.attributes.get("x-ms-client-request-id") == "some client request id" assert network_span.attributes.get("x-ms-request-id") is None assert network_span.attributes.get("http.status_code") == 504 # Exception should propagate status for Opencensus assert network_span.status == 'Transport trouble'
def test_distributed_tracing_policy_solo(http_request, http_response): """Test policy with no other policy and happy path""" settings.tracing_implementation.set_value(FakeSpan) with FakeSpan(name="parent") as root_span: policy = DistributedTracingPolicy() request = http_request("GET", "http://localhost/temp?query=query") request.headers["x-ms-client-request-id"] = "some client request id" pipeline_request = PipelineRequest(request, PipelineContext(None)) policy.on_request(pipeline_request) response = create_http_response(http_response, request, None) response.headers = request.headers response.status_code = 202 response.headers["x-ms-request-id"] = "some request id" assert request.headers.get("traceparent") == '123456789' policy.on_response( pipeline_request, PipelineResponse(request, response, PipelineContext(None))) time.sleep(0.001) policy.on_request(pipeline_request) try: raise ValueError("Transport trouble") except: policy.on_exception(pipeline_request) # Check on_response network_span = root_span.children[0] assert network_span.name == "/temp" assert network_span.attributes.get("http.method") == "GET" assert network_span.attributes.get("component") == "http" assert network_span.attributes.get( "http.url") == "http://localhost/temp?query=query" assert network_span.attributes.get("http.user_agent") is None assert network_span.attributes.get("x-ms-request-id") == "some request id" assert network_span.attributes.get( "x-ms-client-request-id") == "some client request id" assert network_span.attributes.get("http.status_code") == 202 # Check on_exception network_span = root_span.children[1] assert network_span.name == "/temp" assert network_span.attributes.get("http.method") == "GET" assert network_span.attributes.get("component") == "http" assert network_span.attributes.get( "http.url") == "http://localhost/temp?query=query" assert network_span.attributes.get( "x-ms-client-request-id") == "some client request id" assert network_span.attributes.get("http.user_agent") is None assert network_span.attributes.get("x-ms-request-id") == None assert network_span.attributes.get("http.status_code") == 504
def test_distributed_tracing_policy_solo(): """Test policy with no other policy and happy path""" with ContextHelper(): exporter = MockExporter() trace = tracer_module.Tracer(sampler=AlwaysOnSampler(), exporter=exporter) with trace.span("parent"): policy = DistributedTracingPolicy() request = HttpRequest("GET", "http://127.0.0.1/temp?query=query") request.headers["x-ms-client-request-id"] = "some client request id" pipeline_request = PipelineRequest(request, PipelineContext(None)) policy.on_request(pipeline_request) response = HttpResponse(request, None) response.headers = request.headers response.status_code = 202 response.headers["x-ms-request-id"] = "some request id" ctx = trace.span_context header = trace.propagator.to_headers(ctx) assert request.headers.get("traceparent") == header.get("traceparent") policy.on_response(pipeline_request, PipelineResponse(request, response, PipelineContext(None))) time.sleep(0.001) policy.on_request(pipeline_request) policy.on_exception(pipeline_request) trace.finish() exporter.build_tree() parent = exporter.root network_span = parent.children[0] assert network_span.span_data.name == "/temp" assert network_span.span_data.attributes.get("http.method") == "GET" assert network_span.span_data.attributes.get("component") == "http" assert network_span.span_data.attributes.get("http.url") == "http://127.0.0.1/temp?query=query" assert network_span.span_data.attributes.get("http.user_agent") is None assert network_span.span_data.attributes.get("x-ms-request-id") == "some request id" assert network_span.span_data.attributes.get("x-ms-client-request-id") == "some client request id" assert network_span.span_data.attributes.get("http.status_code") == 202 network_span = parent.children[1] assert network_span.span_data.name == "/temp" assert network_span.span_data.attributes.get("http.method") == "GET" assert network_span.span_data.attributes.get("component") == "http" assert network_span.span_data.attributes.get("http.url") == "http://127.0.0.1/temp?query=query" assert network_span.span_data.attributes.get("x-ms-client-request-id") == "some client request id" assert network_span.span_data.attributes.get("http.user_agent") is None assert network_span.span_data.attributes.get("x-ms-request-id") == None assert network_span.span_data.attributes.get("http.status_code") == 504
def _create_appconfig_pipeline( self, credential, base_url=None, aad_mode=False, **kwargs ): transport = kwargs.get("transport") policies = kwargs.get("policies") if policies is None: # [] is a valid policy list if aad_mode: scope = base_url.strip("/") + "/.default" if hasattr(credential, "get_token"): credential_policy = BearerTokenCredentialPolicy(credential, scope) else: raise TypeError( "Please provide an instance from azure-identity " "or a class that implement the 'get_token protocol" ) else: credential_policy = AppConfigRequestsCredentialsPolicy(credential) policies = [ self._config.headers_policy, self._config.user_agent_policy, self._config.retry_policy, self._sync_token_policy, credential_policy, self._config.logging_policy, # HTTP request/response log DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ContentDecodePolicy(**kwargs), ] if not transport: transport = RequestsTransport(**kwargs) return Pipeline(transport, policies)
def _create_pipeline(self, credential, **kwargs): credential_policy = None if credential is None: raise ValueError("Parameter 'credential' must not be None.") if hasattr(credential, "get_token"): credential_policy = AsyncBearerTokenCredentialPolicy( credential, "https://cognitiveservices.azure.com/.default") elif isinstance(credential, six.string_types): credential_policy = CognitiveServicesCredentialPolicy(credential) elif credential is not None: raise TypeError("Unsupported credential: {}".format(credential)) config = self._create_configuration(**kwargs) config.transport = kwargs.get("transport") # type: ignore if not config.transport: try: from azure.core.pipeline.transport import AioHttpTransport except ImportError: raise ImportError( "Unable to create async transport. Please check aiohttp is installed." ) config.transport = AioHttpTransport(**kwargs) policies = [ config.headers_policy, config.user_agent_policy, RequestIdPolicy(**kwargs), config.proxy_policy, AsyncRedirectPolicy(**kwargs), AsyncRetryPolicy(**kwargs), credential_policy, config.logging_policy, AsyncTextAnalyticsResponseHook(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs) ] return AsyncPipeline(config.transport, policies=policies)
def __init__(self, endpoint, client_cls, config=None, client_id=None, **kwargs): # type: (str, Type, Optional[Configuration], Optional[str], **Any) -> None self._identity_config = kwargs.pop("identity_config", None) or {} if client_id: if os.environ.get( EnvironmentVariables.MSI_ENDPOINT) and os.environ.get( EnvironmentVariables.MSI_SECRET): # App Service: version 2017-09-1 accepts client ID as parameter "clientid" if "clientid" not in self._identity_config: self._identity_config["clientid"] = client_id elif "client_id" not in self._identity_config: self._identity_config["client_id"] = client_id config = config or self._create_config(**kwargs) policies = [ ContentDecodePolicy(), config.headers_policy, config.user_agent_policy, config.retry_policy, config.logging_policy, DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ] self._client = client_cls(endpoint=endpoint, config=config, policies=policies, **kwargs)
def _build_pipeline(self, **kwargs): # pylint: disable=no-self-use transport = kwargs.get('transport') policies = kwargs.get('policies') credential_policy = \ AsyncServiceBusSharedKeyCredentialPolicy(self._endpoint, self._credential, "Authorization") \ if isinstance(self._credential, ServiceBusSharedKeyCredential) \ else AsyncBearerTokenCredentialPolicy(self._credential, JWT_TOKEN_SCOPE) if policies is None: # [] is a valid policy list policies = [ RequestIdPolicy(**kwargs), self._config.headers_policy, self._config.user_agent_policy, self._config.proxy_policy, ContentDecodePolicy(**kwargs), ServiceBusXMLWorkaroundPolicy(), self._config.redirect_policy, self._config.retry_policy, credential_policy, self._config.logging_policy, DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ] if not transport: transport = AioHttpTransport(**kwargs) return AsyncPipeline(transport, policies)
def _create_pipeline(self, credential, **kwargs): # type: (Any, **Any) -> Tuple[Configuration, Pipeline] self._credential_policy = None if hasattr(credential, "get_token"): self._credential_policy = BearerTokenCredentialPolicy( credential, STORAGE_OAUTH_SCOPE) elif isinstance(credential, SharedKeyCredentialPolicy): self._credential_policy = credential elif credential is not None: raise TypeError("Unsupported credential: {}".format(credential)) config = kwargs.get("_configuration") or create_configuration(**kwargs) if kwargs.get("_pipeline"): return config, kwargs["_pipeline"] config.transport = kwargs.get("transport") # type: ignore kwargs.setdefault("connection_timeout", CONNECTION_TIMEOUT) kwargs.setdefault("read_timeout", READ_TIMEOUT) if not config.transport: config.transport = RequestsTransport(**kwargs) policies = [ config.headers_policy, config.proxy_policy, config.user_agent_policy, StorageContentValidation(), StorageRequestHook(**kwargs), self._credential_policy, ContentDecodePolicy(response_encoding="utf-8"), RedirectPolicy(**kwargs), StorageHosts(hosts=self._hosts, **kwargs), config.retry_policy, config.logging_policy, StorageResponseHook(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs) ] return config, Pipeline(config.transport, policies=policies)
def _create_pipeline(self, credential, **kwargs): credential_policy = None if credential is None: raise ValueError("Parameter 'credential' must not be None.") if hasattr(credential, "get_token"): credential_policy = BearerTokenCredentialPolicy( credential, "https://cognitiveservices.azure.com/.default" ) elif isinstance(credential, TextAnalyticsApiKeyCredential): credential_policy = CognitiveServicesCredentialPolicy(credential) elif credential is not None: raise TypeError("Unsupported credential: {}. Use an instance of TextAnalyticsApiKeyCredential " "or a token credential from azure.identity".format(type(credential))) config = self._create_configuration(**kwargs) config.transport = kwargs.get("transport") # type: ignore if not config.transport: config.transport = RequestsTransport(**kwargs) policies = [ config.headers_policy, config.user_agent_policy, RequestIdPolicy(**kwargs), config.proxy_policy, config.redirect_policy, config.retry_policy, credential_policy, config.logging_policy, TextAnalyticsResponseHook(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ] return Pipeline(config.transport, policies=policies)
def _configure_policies(self, **kwargs): # type: (**Any) -> None try: from azure.core.pipeline.transport import AioHttpTransport if not kwargs.get("transport"): kwargs.setdefault("transport", AioHttpTransport(**kwargs)) except ImportError: raise ImportError( "Unable to create async transport. Please check aiohttp is installed." ) kwargs.setdefault("connection_timeout", CONNECTION_TIMEOUT) kwargs.setdefault("read_timeout", READ_TIMEOUT) self._policies = [ StorageHeadersPolicy(**kwargs), ProxyPolicy(**kwargs), UserAgentPolicy(sdk_moniker=SDK_MONIKER, **kwargs), StorageContentValidation(), StorageRequestHook(**kwargs), self._credential_policy, ContentDecodePolicy(response_encoding="utf-8"), AsyncRedirectPolicy(**kwargs), StorageHosts(hosts=self._hosts, **kwargs), AsyncTablesRetryPolicy(**kwargs), StorageLoggingPolicy(**kwargs), AsyncStorageResponseHook(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ]
def test_span_namer(http_request, http_response): settings.tracing_implementation.set_value(FakeSpan) with FakeSpan(name="parent") as root_span: request = http_request("GET", "http://localhost/temp?query=query") pipeline_request = PipelineRequest(request, PipelineContext(None)) def fixed_namer(http_request): assert http_request is request return "overridenname" policy = DistributedTracingPolicy(network_span_namer=fixed_namer) policy.on_request(pipeline_request) response = create_http_response(http_response, request, None) response.headers = request.headers response.status_code = 202 policy.on_response( pipeline_request, PipelineResponse(request, response, PipelineContext(None))) def operation_namer(http_request): assert http_request is request return "operation level name" pipeline_request.context.options[ 'network_span_namer'] = operation_namer policy.on_request(pipeline_request) response = create_http_response(http_response, request, None) response.headers = request.headers response.status_code = 202 policy.on_response( pipeline_request, PipelineResponse(request, response, PipelineContext(None))) # Check init kwargs network_span = root_span.children[0] assert network_span.name == "overridenname" # Check operation kwargs network_span = root_span.children[1] assert network_span.name == "operation level name"
def _get_policies(config, **kwargs): return [ HeadersPolicy(**kwargs), UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs), config.proxy_policy, config.retry_policy, NetworkTraceLoggingPolicy(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ]
def _get_policies(config: "Configuration", **kwargs: "Any") -> "List[PolicyType]": return [ UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs), config.proxy_policy, config.retry_policy, ArcChallengeAuthPolicy(), NetworkTraceLoggingPolicy(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ]
def _build_pipeline(self, config=None, policies=None, transport=None, **kwargs): config = config or self._create_config(**kwargs) policies = policies or [ ContentDecodePolicy(), config.retry_policy, config.logging_policy, DistributedTracingPolicy(), ] if not transport: transport = RequestsTransport(**kwargs) return Pipeline(transport=transport, policies=policies)
def __init__(self, endpoint, client_cls, config=None, client_id=None, **kwargs): # type: (str, Type, Optional[Configuration], Optional[str], Any) -> None self._client_id = client_id config = config or self._create_config(**kwargs) policies = [ ContentDecodePolicy(), config.headers_policy, config.user_agent_policy, config.retry_policy, config.logging_policy, DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ] self._client = client_cls(endpoint=endpoint, config=config, policies=policies, **kwargs)
def __init__(self, config: "Optional[Configuration]" = None, policies: "Optional[Iterable[HTTPPolicy]]" = None, transport: "Optional[AsyncHttpTransport]" = None, **kwargs: "Any") -> None: config = config or self._create_config(**kwargs) policies = policies or [ ContentDecodePolicy(), config.retry_policy, config.logging_policy, DistributedTracingPolicy(), ] if not transport: transport = AsyncioRequestsTransport(**kwargs) self._pipeline = AsyncPipeline(transport=transport, policies=policies) super().__init__(**kwargs)
def _configure_policies(self, **kwargs): return [ RequestIdPolicy(**kwargs), StorageHeadersPolicy(**kwargs), UserAgentPolicy(sdk_moniker=SDK_MONIKER, **kwargs), ProxyPolicy(**kwargs), self._credential_policy, ContentDecodePolicy(response_encoding="utf-8"), RedirectPolicy(**kwargs), StorageHosts(**kwargs), TablesRetryPolicy(**kwargs), CustomHookPolicy(**kwargs), NetworkTraceLoggingPolicy(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ]
def __init__(self, config: "Optional[Configuration]" = None, policies: "Optional[Iterable[AsyncHTTPPolicy]]" = None, transport: "Optional[AsyncHttpTransport]" = None, **kwargs: "Any") -> None: config = config or self._create_config(**kwargs) policies = policies or [ config.retry_policy, config.logging_policy, DistributedTracingPolicy() ] self._transport = transport or AioHttpTransport(configuration=config) atexit.register( self._close_transport_session) # prevent aiohttp warnings self._pipeline = AsyncPipeline(transport=self._transport, policies=policies)
def _get_policies(config, **kwargs): logging_policy = HttpLoggingPolicy(**kwargs) logging_policy.allowed_header_names.add("x-ms-keyvault-network-info") return [ config.headers_policy, UserAgentPolicy(base_user_agent=USER_AGENT, **kwargs), config.proxy_policy, ContentDecodePolicy(), config.redirect_policy, config.retry_policy, config.authentication_policy, config.logging_policy, DistributedTracingPolicy(**kwargs), logging_policy, ]
def _default_policies(config, **kwargs): return [ RequestIdPolicy(**kwargs), ARMAutoResourceProviderRegistrationPolicy(), config.headers_policy, config.user_agent_policy, config.proxy_policy, ContentDecodePolicy(**kwargs), config.redirect_policy, config.retry_policy, config.authentication_policy, config.custom_hook_policy, config.logging_policy, DistributedTracingPolicy(**kwargs), ARMHttpLoggingPolicy(**kwargs), ]
def _build_pipeline(self, config=None, policies=None, transport=None, **kwargs): # type: (Optional[Configuration], Optional[List[Policy]], Optional[HttpTransport], **Any) -> Pipeline config = config or _create_config(**kwargs) policies = policies or [ config.user_agent_policy, config.proxy_policy, config.retry_policy, config.logging_policy, DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ] if not transport: from azure.core.pipeline.transport import RequestsTransport transport = RequestsTransport(**kwargs) return Pipeline(transport=transport, policies=policies)
def _build_pipeline(self, config, transport, **kwargs): # type: (Configuration, HttpTransport, **Any) -> Pipeline policies = [ config.headers_policy, config.user_agent_policy, config.proxy_policy, config.redirect_policy, config.retry_policy, config.authentication_policy, config.logging_policy, DistributedTracingPolicy(), ] if transport is None: transport = RequestsTransport(**kwargs) return Pipeline(transport, policies=policies)
def _create_pipeline(self, credential, **kwargs): # type: (Any, **Any) -> Tuple[Configuration, Pipeline] self._credential_policy = None if hasattr(credential, 'get_token'): self._credential_policy = AsyncBearerTokenCredentialPolicy( credential, STORAGE_OAUTH_SCOPE) elif isinstance(credential, SharedKeyCredentialPolicy): self._credential_policy = credential elif isinstance(credential, AzureSasCredential): self._credential_policy = AzureSasCredentialPolicy(credential) elif credential is not None: raise TypeError("Unsupported credential: {}".format(credential)) config = kwargs.get('_configuration') or create_configuration(**kwargs) if kwargs.get('_pipeline'): return config, kwargs['_pipeline'] config.transport = kwargs.get('transport') # type: ignore kwargs.setdefault("connection_timeout", CONNECTION_TIMEOUT) kwargs.setdefault("read_timeout", READ_TIMEOUT) if not config.transport: try: from azure.core.pipeline.transport import AioHttpTransport except ImportError: raise ImportError( "Unable to create async transport. Please check aiohttp is installed." ) config.transport = AioHttpTransport(**kwargs) policies = [ QueueMessagePolicy(), config.headers_policy, config.proxy_policy, config.user_agent_policy, StorageContentValidation(), StorageRequestHook(**kwargs), self._credential_policy, ContentDecodePolicy(response_encoding="utf-8"), AsyncRedirectPolicy(**kwargs), StorageHosts(hosts=self._hosts, **kwargs), # type: ignore config.retry_policy, config.logging_policy, AsyncStorageResponseHook(**kwargs), DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ] if kwargs.get("_additional_pipeline_policies"): policies = policies + kwargs.get("_additional_pipeline_policies") return config, AsyncPipeline(config.transport, policies=policies)
def _create_appconfig_pipeline(self, **kwargs): transport = kwargs.get('transport') policies = kwargs.get('policies') if policies is None: # [] is a valid policy list policies = [ self.config.headers_policy, self.config.user_agent_policy, AppConfigRequestsCredentialsPolicy(self.config.credentials), self.config.retry_policy, self.config.logging_policy, # HTTP request/response log DistributedTracingPolicy(), ] if not transport: transport = RequestsTransport(**kwargs) return Pipeline(transport, policies)
def __init__( self, config: "Optional[Configuration]" = None, policies: "Optional[Iterable[AsyncHTTPPolicy]]" = None, transport: "Optional[AsyncHttpTransport]" = None, **kwargs: "Any" ) -> None: config = config or self._create_config(**kwargs) policies = policies or [ config.user_agent_policy, config.proxy_policy, config.retry_policy, config.logging_policy, DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ] self._transport = transport or AioHttpTransport(configuration=config) self._pipeline = AsyncPipeline(transport=self._transport, policies=policies)
def _policies(credential, **kwargs): # type: (Union[AzureKeyCredential, EventGridSharedAccessSignatureCredential], Any) -> List[Any] auth_policy = _get_authentication_policy(credential) sdk_moniker = 'eventgrid/{}'.format(VERSION) policies = [ RequestIdPolicy(**kwargs), HeadersPolicy(**kwargs), UserAgentPolicy(sdk_moniker=sdk_moniker, **kwargs), ProxyPolicy(**kwargs), ContentDecodePolicy(**kwargs), RedirectPolicy(**kwargs), RetryPolicy(**kwargs), auth_policy, CustomHookPolicy(**kwargs), NetworkTraceLoggingPolicy(**kwargs), DistributedTracingPolicy(**kwargs), CloudEventDistributedTracingPolicy(), HttpLoggingPolicy(**kwargs) ] return policies
def _build_pipeline(config=None, policies=None, transport=None, **kwargs): # type: (Optional[Configuration], Optional[PolicyList], Optional[HttpTransport], **Any) -> Pipeline config = config or _create_config(**kwargs) if policies is None: # [] is a valid policy list policies = [ ContentDecodePolicy(), config.user_agent_policy, config.proxy_policy, config.retry_policy, config.logging_policy, DistributedTracingPolicy(**kwargs), HttpLoggingPolicy(**kwargs), ] if not transport: transport = RequestsTransport(**kwargs) return Pipeline(transport=transport, policies=policies)
def _policies(credential: Union[AzureKeyCredential, AzureSasCredential], **kwargs: Any) -> List[Any]: auth_policy = _get_authentication_policy(credential) sdk_moniker = 'eventgridpublisherclient/{}'.format(VERSION) policies = [ RequestIdPolicy(**kwargs), HeadersPolicy(**kwargs), UserAgentPolicy(sdk_moniker=sdk_moniker, **kwargs), ProxyPolicy(**kwargs), ContentDecodePolicy(**kwargs), AsyncRedirectPolicy(**kwargs), AsyncRetryPolicy(**kwargs), auth_policy, CustomHookPolicy(**kwargs), NetworkTraceLoggingPolicy(**kwargs), DistributedTracingPolicy(**kwargs), CloudEventDistributedTracingPolicy(), HttpLoggingPolicy(**kwargs) ] return policies