feat(logs): add OTEL_LOG_LEVEL support

Author: grvmishra788

opentelemetry-sdk/src/opentelemetry/sdk/_logs/_internal/__init__.py

@@ -56,6 +56,7 @@
 from opentelemetry.sdk.environment_variables import (
     OTEL_ATTRIBUTE_COUNT_LIMIT,
     OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT,
+    OTEL_LOG_LEVEL,
     OTEL_SDK_DISABLED,
 )
 from opentelemetry.sdk.resources import Resource
@@ -75,8 +76,34 @@
 _DEFAULT_OTEL_ATTRIBUTE_COUNT_LIMIT = 128
 _ENV_VALUE_UNSET = ""
 
+# "warn" is included alongside "warning" because the OTel spec default is
+# "info" (lowercase OTel style) and OTel canonical short names use "WARN",
+# so users following OTel documentation will naturally try "warn".
+_OTEL_LOG_LEVEL_TO_PYTHON = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warn": logging.WARNING,
+    "warning": logging.WARNING,
+    "error": logging.ERROR,
+    "critical": logging.CRITICAL,
+}
+
 _logger = logging.getLogger(__name__)
 
+# Target opentelemetry.sdk (not the module-level _logger) so the level
+# propagates to all SDK sub-modules: trace, metrics, logs, exporters.
+_otel_log_level_raw = environ.get(OTEL_LOG_LEVEL)
+_otel_log_level = (_otel_log_level_raw or "info").lower()
+if _otel_log_level_raw and _otel_log_level not in _OTEL_LOG_LEVEL_TO_PYTHON:
+    _logger.warning(
+        "Invalid value for OTEL_LOG_LEVEL: %r. "
+        "Valid values: debug, info, warn, warning, error, critical. "
+        "Defaulting to INFO.",
+        _otel_log_level_raw,
+    )
+_python_level = _OTEL_LOG_LEVEL_TO_PYTHON.get(_otel_log_level, logging.INFO)
+logging.getLogger("opentelemetry.sdk").setLevel(_python_level)
+
 
 class BytesEncoder(json.JSONEncoder):
     def default(self, o):
@@ -718,6 +745,7 @@ def emit(
         """
         if not self._is_enabled():
             return
+
         # If a record is provided, use it directly
         if record is not None:
             if not isinstance(record, ReadWriteLogRecord):

opentelemetry-sdk/tests/logs/test_logs.py

@@ -14,9 +14,12 @@
 
 # pylint: disable=protected-access
 
+import importlib
+import logging
 import unittest
 from unittest.mock import Mock, patch
 
+import opentelemetry.sdk._logs._internal as _logs_internal
 from opentelemetry._logs import LogRecord, SeverityNumber
 from opentelemetry.context import get_current
 from opentelemetry.metrics import NoOpMeterProvider
@@ -26,14 +29,18 @@
     ReadableLogRecord,
 )
 from opentelemetry.sdk._logs._internal import (
+    _OTEL_LOG_LEVEL_TO_PYTHON,
     LoggerMetrics,
     NoOpLogger,
     SynchronousMultiLogRecordProcessor,
     _disable_logger_configurator,
     _LoggerConfig,
     _RuleBasedLoggerConfigurator,
 )
-from opentelemetry.sdk.environment_variables import OTEL_SDK_DISABLED
+from opentelemetry.sdk.environment_variables import (
+    OTEL_LOG_LEVEL,
+    OTEL_SDK_DISABLED,
+)
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.util.instrumentation import (
     InstrumentationScope,
@@ -354,3 +361,84 @@ def test_can_emit_with_keywords_arguments(self):
         self.assertEqual(result_log_record.attributes, {"some": "attributes"})
         self.assertEqual(result_log_record.event_name, "event_name")
         self.assertEqual(log_data.resource, logger.resource)
+
+
+class TestOtelLogLevelEnvVar(unittest.TestCase):
+    """Tests for OTEL_LOG_LEVEL → SDK internal logger level."""
+
+    def setUp(self):
+        self._sdk_logger = logging.getLogger("opentelemetry.sdk")
+
+    def tearDown(self):
+        importlib.reload(_logs_internal)
+
+    def test_otel_log_level_to_python_mapping_accepted_values(self):
+        expected_keys = {
+            "debug",
+            "info",
+            "warn",
+            "warning",
+            "error",
+            "critical",
+        }
+        self.assertEqual(set(_OTEL_LOG_LEVEL_TO_PYTHON.keys()), expected_keys)
+
+    @patch.dict("os.environ", {OTEL_LOG_LEVEL: ""})
+    def test_default_level_is_info(self):
+        importlib.reload(_logs_internal)
+        self.assertEqual(self._sdk_logger.level, logging.INFO)
+
+    def test_invalid_value_warns_and_defaults_to_info(self):
+        # "trace", "verbose", "none" are valid in other SDKs but not accepted here
+        for invalid in ("INVALID", "trace", "verbose", "none", "0"):
+            with self.subTest(invalid=invalid):
+                with patch.dict("os.environ", {OTEL_LOG_LEVEL: invalid}):
+                    with self.assertLogs(
+                        "opentelemetry.sdk._logs._internal",
+                        level=logging.WARNING,
+                    ):
+                        importlib.reload(_logs_internal)
+                self.assertEqual(self._sdk_logger.level, logging.INFO)
+
+    def test_case_insensitive(self):
+        for env_value, expected_level in (
+            ("DEBUG", logging.DEBUG),
+            ("WARN", logging.WARNING),
+            ("Warning", logging.WARNING),
+            ("cRiTiCaL", logging.CRITICAL),
+        ):
+            with self.subTest(env_value=env_value):
+                with patch.dict("os.environ", {OTEL_LOG_LEVEL: env_value}):
+                    importlib.reload(_logs_internal)
+                self.assertEqual(self._sdk_logger.level, expected_level)
+
+    @patch.dict("os.environ", {OTEL_LOG_LEVEL: "critical"})
+    def test_level_propagates_to_child_loggers(self):
+        importlib.reload(_logs_internal)
+        self.assertEqual(
+            self._sdk_logger.getChild("trace").getEffectiveLevel(),
+            logging.CRITICAL,
+        )
+        self.assertEqual(
+            self._sdk_logger.getChild("metrics").getEffectiveLevel(),
+            logging.CRITICAL,
+        )
+        self.assertEqual(
+            self._sdk_logger.getChild("logs").getEffectiveLevel(),
+            logging.CRITICAL,
+        )
+
+    def test_all_valid_values_map_to_correct_level(self):
+        cases = [
+            ("debug", logging.DEBUG),
+            ("info", logging.INFO),
+            ("warn", logging.WARNING),
+            ("warning", logging.WARNING),
+            ("error", logging.ERROR),
+            ("critical", logging.CRITICAL),
+        ]
+        for env_value, expected_level in cases:
+            with self.subTest(env_value=env_value):
+                with patch.dict("os.environ", {OTEL_LOG_LEVEL: env_value}):
+                    importlib.reload(_logs_internal)
+                self.assertEqual(self._sdk_logger.level, expected_level)