def test_request_id_already_exists(): """Test policy with no other policy and happy path""" request_id_policy = RequestIdPolicy() request = HttpRequest('GET', 'http://localhost/') request.headers["x-ms-client-request-id"] = "VALUE" pipeline_request = PipelineRequest(request, PipelineContext(None)) request_id_policy.on_request(pipeline_request) assert request.headers["x-ms-client-request-id"] == "VALUE"
def test_request_id_policy_fix_id(): """Test policy with no other policy and happy path""" test_request_id = 'test_request_id' request_id_policy = RequestIdPolicy(request_id=test_request_id) request = HttpRequest('GET', 'http://127.0.0.1/') pipeline_request = PipelineRequest(request, PipelineContext(None)) request_id_policy.on_request(pipeline_request) assert request.headers["x-ms-client-request-id"] == test_request_id
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 _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): 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 test_request_id_policy(auto_request_id, request_id_init, request_id_set, request_id_req): """Test policy with no other policy and happy path""" kwargs = {} if auto_request_id is not None: kwargs['auto_request_id'] = auto_request_id if request_id_init != "_unset": kwargs['request_id'] = request_id_init request_id_policy = RequestIdPolicy(**kwargs) if request_id_set != "_unset": request_id_policy.set_request_id(request_id_set) request = HttpRequest('GET', 'http://localhost/') pipeline_request = PipelineRequest(request, PipelineContext(None)) if request_id_req != "_unset": pipeline_request.context.options['request_id'] = request_id_req with mock.patch('uuid.uuid1', return_value="VALUE"): request_id_policy.on_request(pipeline_request) assert all(v is not None for v in request.headers.values()) if request_id_req != "_unset" and request_id_req: assert request.headers["x-ms-client-request-id"] == request_id_req elif not request_id_req: assert not "x-ms-client-request-id" in request.headers elif request_id_set != "_unset" and request_id_set: assert request.headers["x-ms-client-request-id"] == request_id_set elif not request_id_set: assert not "x-ms-client-request-id" in request.headers elif request_id_init != "_unset" and request_id_init: assert request.headers["x-ms-client-request-id"] == request_id_init elif not request_id_init: assert not "x-ms-client-request-id" in request.headers elif auto_request_id or auto_request_id is None: assert request.headers["x-ms-client-request-id"] == "VALUE" else: assert not "x-ms-client-request-id" in request.headers
def test_example_request_id_policy(): url = "https://bing.com" policies = [UserAgentPolicy("myuseragent"), RedirectPolicy()] # [START request_id_policy] from azure.core.pipeline.policies import HeadersPolicy request_id_policy = RequestIdPolicy() request_id_policy.set_request_id('azconfig-test') # Or headers can be added per operation. These headers will supplement existing headers # or those defined in the config headers policy. They will also overwrite existing # identical headers. policies.append(request_id_policy) client = PipelineClient(base_url=url, policies=policies) request = client.get(url) pipeline_response = client._pipeline.run(request, request_id="azconfig-test") # [END request_id_policy] response = pipeline_response.http_response assert isinstance(response.status_code, int)
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 _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 __init__(self, **kwargs: Any) -> None: """Azure Monitor base exporter for OpenTelemetry. :param options: Exporter configuration options. :type options: ~azure.opentelemetry.exporter.azuremonitor.options.ExporterOptions :keyword str connection_string: The connection string to be used for authentication :rtype: None """ options = ExporterOptions(**kwargs) parsed_connection_string = ConnectionStringParser( options.connection_string) self._instrumentation_key = parsed_connection_string.instrumentation_key self._timeout = 10.0 # networking timeout in seconds temp_suffix = self._instrumentation_key or "" default_storage_path = os.path.join(tempfile.gettempdir(), TEMPDIR_PREFIX + temp_suffix) config = AzureMonitorClientConfiguration( parsed_connection_string.endpoint, **kwargs) policies = [ RequestIdPolicy(**kwargs), 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, # Explicitly disabling to avoid infinite loop of Span creation when data is exported # DistributedTracingPolicy(**kwargs), config.http_logging_policy or HttpLoggingPolicy(**kwargs) ] self.client = AzureMonitorClient( host=parsed_connection_string.endpoint, connection_timeout=self._timeout, policies=policies, **kwargs) self.storage = LocalFileStorage( path=default_storage_path, max_size=50 * 1024 * 1024, # Maximum size in bytes. maintenance_period=60, # Maintenance interval in seconds. retention_period=7 * 24 * 60 * 60, # Retention period in seconds )
def __init__(self, **kwargs: Any) -> None: """Azure Monitor base exporter for OpenTelemetry. :keyword str api_version: The service API version used. Defaults to latest. :rtype: None """ parsed_connection_string = ConnectionStringParser( kwargs.get('connection_string')) self._instrumentation_key = parsed_connection_string.instrumentation_key self._timeout = 10.0 # networking timeout in seconds self._api_version = kwargs.get('api_version') or _SERVICE_API_LATEST self._consecutive_redirects = 0 # To prevent circular redirects temp_suffix = self._instrumentation_key or "" default_storage_path = os.path.join(tempfile.gettempdir(), _TEMPDIR_PREFIX + temp_suffix) config = AzureMonitorClientConfiguration( parsed_connection_string.endpoint, **kwargs) policies = [ RequestIdPolicy(**kwargs), config.headers_policy, config.user_agent_policy, config.proxy_policy, ContentDecodePolicy(**kwargs), # Handle redirects in exporter, set new endpoint if redirected RedirectPolicy(permit_redirects=False), config.retry_policy, config.authentication_policy, config.custom_hook_policy, config.logging_policy, # Explicitly disabling to avoid infinite loop of Span creation when data is exported # DistributedTracingPolicy(**kwargs), config.http_logging_policy or HttpLoggingPolicy(**kwargs) ] self.client = AzureMonitorClient( host=parsed_connection_string.endpoint, connection_timeout=self._timeout, policies=policies, **kwargs) self.storage = LocalFileStorage( path=default_storage_path, max_size=50 * 1024 * 1024, # Maximum size in bytes. maintenance_period=60, # Maintenance interval in seconds. retention_period=7 * 24 * 60 * 60, # Retention period in seconds )
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 _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
def _create_pipeline(self, credential, endpoint=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 = endpoint.strip("/") + "/.default" if hasattr(credential, "get_token"): credential_policy = AsyncBearerTokenCredentialPolicy( credential, scope) else: raise TypeError( "Please provide an instance from azure-identity " "or a class that implement the 'get_token protocol") else: credential_policy = MetricsAdvisorKeyCredentialPolicy( credential) policies = [ RequestIdPolicy(**kwargs), self._config.headers_policy, self._config.user_agent_policy, self._config.proxy_policy, ContentDecodePolicy(**kwargs), self._config.redirect_policy, self._config.retry_policy, credential_policy, self._config.logging_policy, # HTTP request/response log DistributedTracingPolicy(**kwargs), self._config.http_logging_policy or HttpLoggingPolicy(**kwargs) ] if not transport: transport = AioHttpTransport(**kwargs) return AsyncPipeline(transport, policies)