Add configuration of logging format and logger name via env var in distro (#42035)

Author: lzchen

sdk/monitor/azure-monitor-opentelemetry/CHANGELOG.md

@@ -4,6 +4,9 @@
 
 ### Features Added
 
+- Add configuring of logging format and logger name via environment variables
+    ([#42035](https://github.com/Azure/azure-sdk-for-python/pull/42035))
+
 ### Breaking Changes
 
 ### Bugs Fixed

sdk/monitor/azure-monitor-opentelemetry/README.md

@@ -61,8 +61,8 @@ You can use `configure_azure_monitor` to set up instrumentation for your app to
 |-------------------|----------------------------------------------------|----------------------|
 | `connection_string` | The [connection string][connection_string_doc] for your Application Insights resource. The connection string will be automatically populated from the `APPLICATIONINSIGHTS_CONNECTION_STRING` environment variable if not explicitly passed in. | `APPLICATIONINSIGHTS_CONNECTION_STRING` |
 | `enable_live_metrics` | Enable [live metrics][application_insights_live_metrics] feature. Defaults to `False`. | `N/A` |
-| `logging_formatter` | A Python logging [formatter][python_logging_formatter] that will be used to format collected logs. | `N/A` |
-| `logger_name` | The name of the [Python logger][python_logger] under which telemetry is collected. Setting this value is imperative so logs created from the SDK itself are not tracked. | `N/A` |
+| `logging_formatter` | A Python logging [formatter][python_logging_formatter] that will be used to format collected logs. | `PYTHON_APPLICATIONINSIGHTS_LOGGING_FORMAT` - accepts a STRING field used for formatting, not a [formatter][python_logging_formatter] |
+| `logger_name` | The name of the [Python logger][python_logger] under which telemetry is collected. Setting this value is imperative so logs created from the SDK itself are not tracked. | `PYTHON_APPLICATIONINSIGHTS_LOGGER_NAME` |
 | `instrumentation_options` | A nested dictionary that determines which instrumentations to enable or disable. Instrumentations are referred to by their [Library Names](#officially-supported-instrumentations). For example, `{"azure_sdk": {"enabled": False}, "flask": {"enabled": False}, "django": {"enabled": True}}` will disable Azure Core Tracing and the Flask instrumentation but leave Django and the other default instrumentations enabled. The `OTEL_PYTHON_DISABLED_INSTRUMENTATIONS` environment variable explained below can also be used to disable instrumentations. | `N/A` |
 | `resource` | Specifies the OpenTelemetry [Resource][ot_spec_resource] associated with your application. Passed in [Resource Attributes][ot_spec_resource_attributes] take priority over default attributes and those from [Resource Detectors][ot_python_resource_detectors]. | [OTEL_SERVICE_NAME][ot_spec_service_name], [OTEL_RESOURCE_ATTRIBUTES][ot_spec_resource_attributes], [OTEL_EXPERIMENTAL_RESOURCE_DETECTORS][ot_python_resource_detectors] |
 | `span_processors` | A list of [span processors][ot_span_processor] that will perform processing on each of your spans before they are exported. Useful for filtering/modifying telemetry. | `N/A` |

sdk/monitor/azure-monitor-opentelemetry/azure/monitor/opentelemetry/_constants.py

@@ -33,6 +33,9 @@
 SAMPLER_ARG = "sampler"
 TRACE_EXPORTER_NAMES_ARG = "trace_exporter_names"
 
+LOGGER_NAME_ENV_ARG = "PYTHON_APPLICATIONINSIGHTS_LOGGER_NAME"
+LOGGING_FORMAT_ENV_ARG = "PYTHON_APPLICATIONINSIGHTS_LOGGING_FORMAT"
+
 
 # --------------------Diagnostic/status logging------------------------------
 

sdk/monitor/azure-monitor-opentelemetry/azure/monitor/opentelemetry/_utils/configurations.py

@@ -34,7 +34,9 @@
     ENABLE_LIVE_METRICS_ARG,
     INSTRUMENTATION_OPTIONS_ARG,
     LOGGER_NAME_ARG,
+    LOGGER_NAME_ENV_ARG,
     LOGGING_FORMATTER_ARG,
+    LOGGING_FORMAT_ENV_ARG,
     RESOURCE_ARG,
     SAMPLING_RATIO_ARG,
     SPAN_PROCESSORS_ARG,
@@ -103,14 +105,29 @@ def _default_disable_tracing(configurations):
 
 
 def _default_logger_name(configurations):
-    configurations.setdefault(LOGGER_NAME_ARG, "")
-
+    if LOGGER_NAME_ARG in configurations:
+        return
+    if LOGGER_NAME_ENV_ARG in environ:
+        configurations[LOGGER_NAME_ARG] = environ[LOGGER_NAME_ENV_ARG]
+    else:
+        configurations.setdefault(LOGGER_NAME_ARG, "")
 
 def _default_logging_formatter(configurations):
     formatter = configurations.get(LOGGING_FORMATTER_ARG)
-    if not isinstance(formatter, Formatter):
-        configurations[LOGGING_FORMATTER_ARG] = None
-
+    if formatter:
+        if not isinstance(formatter, Formatter):
+            configurations[LOGGING_FORMATTER_ARG] = None
+            return
+    elif LOGGING_FORMAT_ENV_ARG in environ:
+        try:
+            configurations[LOGGING_FORMATTER_ARG] = Formatter(environ[LOGGING_FORMAT_ENV_ARG])
+        except Exception as ex:  # pylint: disable=broad-exception-caught
+            _logger.warning(  # pylint: disable=do-not-log-exceptions-if-not-debug
+                "Exception occurred when creating logging Formatter from format: %s, %s.",
+                environ[LOGGING_FORMAT_ENV_ARG],
+                ex,
+            )
+            configurations[LOGGING_FORMATTER_ARG] = None
 
 def _default_resource(configurations):
     environ.setdefault(OTEL_EXPERIMENTAL_RESOURCE_DETECTORS, ",".join(_SUPPORTED_RESOURCE_DETECTORS))

sdk/monitor/azure-monitor-opentelemetry/tests/utils/test_configurations.py

@@ -15,6 +15,7 @@
 from os import environ
 from unittest import TestCase
 from unittest.mock import patch
+from logging import Formatter
 
 from opentelemetry.instrumentation.environment_variables import (
     OTEL_PYTHON_DISABLED_INSTRUMENTATIONS,
@@ -23,13 +24,14 @@
     SAMPLING_RATIO_ENV_VAR,
     _get_configurations,
 )
+from azure.monitor.opentelemetry._constants import LOGGER_NAME_ENV_ARG, LOGGING_FORMAT_ENV_ARG
 from opentelemetry.environment_variables import (
     OTEL_LOGS_EXPORTER,
     OTEL_METRICS_EXPORTER,
     OTEL_TRACES_EXPORTER,
 )
 from opentelemetry.sdk.environment_variables import OTEL_EXPERIMENTAL_RESOURCE_DETECTORS
-from opentelemetry.sdk.resources import Resource, Attributes
+from opentelemetry.sdk.resources import Resource
 
 from azure.monitor.opentelemetry._version import VERSION
 
@@ -260,3 +262,112 @@ def test_merge_instrumentation_options_extra_args(self, resource_create_mock):
                 "urllib3": {"enabled": True},
             },
         )
+
+    @patch.dict(
+        "os.environ",
+        {
+            LOGGER_NAME_ENV_ARG: "test_env_logger",
+        },
+        clear=True,
+    )
+    def test_get_configurations_logger_name_env_var(self):
+        configurations = _get_configurations()
+
+        self.assertEqual(configurations["logger_name"], "test_env_logger")
+
+    @patch.dict(
+        "os.environ",
+        {
+            LOGGER_NAME_ENV_ARG: "test_env_logger",
+        },
+        clear=True,
+    )
+    def test_get_configurations_logger_name_param_overrides_env_var(self):
+        configurations = _get_configurations(logger_name="test_param_logger")
+
+        self.assertEqual(configurations["logger_name"], "test_param_logger")
+
+    @patch.dict(
+        "os.environ",
+        {
+            LOGGING_FORMAT_ENV_ARG: "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        },
+        clear=True,
+    )
+    def test_get_configurations_logging_format_env_var(self):
+        configurations = _get_configurations()
+
+        formatter = configurations["logging_formatter"]
+        self.assertIsNotNone(formatter)
+        self.assertIsInstance(formatter, Formatter)
+        # Test that the formatter works correctly with a sample log record
+        import logging
+        record = logging.LogRecord(
+            name="test_logger",
+            level=logging.INFO,
+            pathname="test.py",
+            lineno=1,
+            msg="test message",
+            args=(),
+            exc_info=None,
+        )
+        # Type assertion for mypy
+        assert isinstance(formatter, Formatter)
+        formatted = formatter.format(record)
+        self.assertIn("test_logger", formatted)
+        self.assertIn("INFO", formatted)
+        self.assertIn("test message", formatted)
+
+    @patch.dict(
+        "os.environ",
+        {
+            LOGGING_FORMAT_ENV_ARG: "invalid format %(nonexistent)z",
+        },
+        clear=True,
+    )
+    @patch("azure.monitor.opentelemetry._utils.configurations._logger")
+    def test_get_configurations_logging_format_env_var_invalid_format(self, mock_logger):
+        configurations = _get_configurations()
+
+        # Should be None when format is invalid
+        self.assertIsNone(configurations["logging_formatter"])
+        # Should log a warning
+        mock_logger.warning.assert_called_once()
+        call_args = mock_logger.warning.call_args[0]
+        self.assertIn("Exception occurred when creating logging Formatter", call_args[0])
+        self.assertIn("invalid format %(nonexistent)z", call_args[1])
+
+    @patch.dict(
+        "os.environ",
+        {
+            LOGGING_FORMAT_ENV_ARG: "%(asctime)s - %(message)s",
+        },
+        clear=True,
+    )
+    def test_get_configurations_logging_format_param_overrides_env_var(self):
+        from logging import Formatter
+        custom_formatter = Formatter("%(levelname)s: %(message)s")
+        configurations = _get_configurations(logging_formatter=custom_formatter)
+
+        # Parameter should override environment variable
+        self.assertEqual(configurations["logging_formatter"], custom_formatter)
+
+    @patch.dict(
+        "os.environ",
+        {
+            LOGGING_FORMAT_ENV_ARG: "%(asctime)s - %(message)s",
+        },
+        clear=True,
+    )
+    def test_get_configurations_logging_format_invalid_param_uses_env_var(self):
+        configurations = _get_configurations(logging_formatter="not_a_formatter")
+
+        # Invalid parameter should be set to None, but env var should still be used
+        self.assertIsNone(configurations["logging_formatter"])
+
+    @patch.dict("os.environ", {}, clear=True)
+    def test_get_configurations_logging_format_no_env_var(self):
+        configurations = _get_configurations()
+
+        # Should not have logging_formatter key when no env var is set
+        self.assertNotIn("logging_formatter", configurations)