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)