How do I connect to Azure Monitor Opentelemetry via Corporate Proxy

Shahnawaz 21

May I know how can we connect to Azure Insights using Azure Monitor Opentelemetry library via corporates proxy. I have read the document and also tried to pass the proxies = {"http/https": "hostname:port"} inside configure_azure_monitor(connection_string="APPLICATIONINSIGHTS_CONNECTION_STRING",proxies={"https":"hostname:port"}) but it never worked. May seek you help with the below code.

Sample Example: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/monitor/azure-monitor-opentelemetry/samples

from logging import INFO, getLogger
from azure.monitor.opentelemetry import configure_azure_monitor

configure_azure_monitor(
    # Set logger_name to the name of the logger you want to capture logging telemetry with
    logger_name="my_application_logger",
)

# Logging calls with this logger will be tracked
logger = getLogger("my_application_logger")
logger.setLevel(INFO)

# Logging calls with any logger that is a child logger will also be tracked
logger_child = getLogger("my-application_logger.module")
logger_child.setLevel(INFO)

# Logging calls with this logger will not be tracked
logger_not_tracked = getLogger("not_my_application_logger")
logger_not_tracked.setLevel(INFO)

logger.info("info log")
logger.warning("warning log")
logger.error("error log")

logger.info("info log")
logger.warning("warning log")
logger.error("error log")

logger_not_tracked.info("info log2")
logger_not_tracked.warning("warning log2")
logger_not_tracked.error("error log2")

AnuragSingh-MSFT 20,996 Reputation points

2024-06-20T14:31:31.43+00:00

@Shahnawaz, thank you for posting this question on Microsoft Q&A.

I don't see proxy parameter available for configure_azure_monitor() function. For complete set of parameters, please see azure.monitor.opentelemetry: configure_azure_monitor.

I dont think you can set the proxy specifically for the Monitoring SDK calls from your application. Instead, it would be using the proxy details as available on the system where the application is running. In case there is a document stating otherwise, please do share it so that I can check with the respective team for more details.

Shahnawaz 21

Hello @AnuragSingh-MSFT ,
Thank for reaching out. I also didn't find anything in the document I found while reviewing the code that there is policy related to proxy but seems like this proxy policy is either not set correctly or is not being used. I am sharing the code for you reference you can find the class inside "azure/monitor/opentelemetry/exporter/export/_base.py" file. If you can please help me to investigate further?

class BaseExporter:
    """Azure Monitor base exporter for OpenTelemetry."""

    def __init__(self, **kwargs: Any) -> None:
        """Azure Monitor base exporter for OpenTelemetry.

        :keyword str api_version: The service API version used. Defaults to latest.
        :keyword str connection_string: The connection string used for your Application Insights resource.
        :keyword ManagedIdentityCredential/ClientSecretCredential credential: Token credential, such as ManagedIdentityCredential or ClientSecretCredential, used for Azure Active Directory (AAD) authentication. Defaults to None.
        :keyword bool disable_offline_storage: Determines whether to disable storing failed telemetry records for retry. Defaults to `False`.
        :keyword str storage_directory: Storage path in which to store retry files. Defaults to `<tempfile.gettempdir()>/opentelemetry-python-<your-instrumentation-key>`.
        :rtype: None
        """
        parsed_connection_string = ConnectionStringParser(kwargs.get('connection_string'))

        self._api_version = kwargs.get('api_version') or _SERVICE_API_LATEST
        self._credential = kwargs.get('credential')
        self._consecutive_redirects = 0  # To prevent circular redirects
        self._disable_offline_storage = kwargs.get('disable_offline_storage', False)
        self._endpoint = parsed_connection_string.endpoint
        self._instrumentation_key = parsed_connection_string.instrumentation_key
        self._storage_maintenance_period = kwargs.get('storage_maintenance_period', 60)  # Maintenance interval in seconds.
        self._storage_max_size = kwargs.get('storage_max_size', 50 * 1024 * 1024)  # Maximum size in bytes (default 50MiB)
        self._storage_min_retry_interval = kwargs.get('storage_min_retry_interval', 60)  # minimum retry interval in seconds
        temp_suffix = self._instrumentation_key or ""
        if 'storage_directory' in kwargs:
            self._storage_directory = kwargs.get('storage_directory')
        elif not self._disable_offline_storage:
            self._storage_directory = os.path.join(
                tempfile.gettempdir(), _AZURE_TEMPDIR_PREFIX, _TEMPDIR_PREFIX + temp_suffix
            )
        else:
            self._storage_directory = None
        self._storage_retention_period = kwargs.get('storage_retention_period', 48 * 60 * 60)  # Retention period in seconds (default 48 hrs)
        self._timeout = kwargs.get('timeout', 10.0)  # networking timeout in seconds
        self._distro_version = kwargs.get(_AZURE_MONITOR_DISTRO_VERSION_ARG, '')  # If set, indicates the exporter is instantiated via Azure monitor OpenTelemetry distro. Versions corresponds to distro version.

        config = AzureMonitorClientConfiguration(self._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,
            _get_auth_policy(self._credential, 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=self._endpoint, connection_timeout=self._timeout, policies=policies, **kwargs)
        
        self.storage = None
        
        if not self._disable_offline_storage:
            self.storage = LocalFileStorage(
                path=self._storage_directory,
                max_size=self._storage_max_size,
                maintenance_period=self._storage_maintenance_period,
                retention_period=self._storage_retention_period,
                name="{} Storage".format(self.__class__.__name__),
                lease_period=self._storage_min_retry_interval,
            )
        # specifies whether current exporter is used for collection of instrumentation metrics
        
        self._instrumentation_collection = kwargs.get('instrumentation_collection', False)
        if self._should_collect_stats():
            # Import here to avoid circular dependencies
            from azure.monitor.opentelemetry.exporter.statsbeat._statsbeat import collect_statsbeat_metrics
            collect_statsbeat_metrics(self)

Share via

How do I connect to Azure Monitor Opentelemetry via Corporate Proxy