How do I connect to Azure Monitor Opentelemetry via Corporate Proxy

Shahnawaz 41

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 21,246 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 41

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)

Shilpa Sharma 0 Reputation points Microsoft Employee

2024-06-26T19:46:46.5433333+00:00

@Shahnawaz We are looking into this for you. In the interim, can you please provide the motivation for setting up insights through proxy?
Shahnawaz 41 Reputation points

2024-07-01T06:06:26.01+00:00

Hello @Shilpa Sharma ,

As per our organization policy for Dev work and while we are in the midst of security clearance the all traffic to internet should go via PROXY.

Accepted answer

AnuragSingh-MSFT 21,246 Reputation points

2024-07-02T10:20:04.03+00:00
@Shahnawaz, Users can setup proxypolicy via azure-core apis. configure_azure_monitor api passes the policies to azure monitor client via kwargs. An example of this can be shown below:

from azure.monitor.opentelemetry import configure_azure_monitor from opentelemetry import trace from azure.core.pipeline import policies configure_azure_monitor( proxy_policy=policies.ProxyPolicy( proxies={"http": "http://10.10.1.10:1234"} ) ) tracer = trace.get_tracer(__name__) with tracer.start_as_current_span("hello"): print("Hello, World!") input()

For more details, see the documentation for ProxyPolicy Class of the azure.core.pipeline package.

Hope this helps.

If the answer did not help, please add more context/follow-up question for it. Else, if the answer helped, please click Accept answer so that it can help others in the community looking for help on similar topics.
Please sign in to rate this answer.

1 person found this answer helpful.
Shahnawaz 41 Reputation points

2024-07-03T05:49:23.1133333+00:00

Thanks @AnuragSingh-MSFT for your help the above code worked for me. FYI, its still throw the below error but still I can see the logs inside trace table.

Retrying due to server request error: (<urllib3.connection.HTTPSConnection object at 0x000001E89CF9A8D0>, 'Connection to westus-0.in.applicationinsights.azure.com timed out. (connect timeout=10.0)').

AnuragSingh-MSFT 21,246 Reputation points

2024-07-04T04:23:45.4733333+00:00

Shahnawaz, thank you for the confirmation.

This error seems to be transient and should get resolved soon.
Sign in to comment

Share via

How do I connect to Azure Monitor Opentelemetry via Corporate Proxy

0 additional answers