Update

Author: hectorhdzg

CHANGELOG.md

@@ -14,6 +14,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - docs: Added sqlcommenter example
   ([#4734](https://github.com/open-telemetry/opentelemetry-python/pull/4734))
+- [BREAKING] Remove LogData and extend SDK LogRecord to have instrumentation scope
+  ([#4676](https://github.com/open-telemetry/opentelemetry-python/pull/4676))
 
 ## Version 1.38.0/0.59b0 (2025-10-16)
 
@@ -95,8 +97,6 @@ can cause a deadlock to occur over `logging._lock` in some cases ([#4636](https:
   ([#4669](https://github.com/open-telemetry/opentelemetry-python/pull/4669))
 - Set expected User-Agent in HTTP headers for grpc OTLP exporter
   ([#4658](https://github.com/open-telemetry/opentelemetry-python/pull/4658))
-- Remove LogData and extend SDK LogRecord to have instrumentation scope
-  ([#4676](https://github.com/open-telemetry/opentelemetry-python/pull/4676))
 
 ## Version 1.34.0/0.55b0 (2025-06-04)
 

opentelemetry-sdk/src/opentelemetry/sdk/_events/__init__.py

@@ -23,7 +23,6 @@
 from opentelemetry._events import EventLoggerProvider as APIEventLoggerProvider
 from opentelemetry._logs import NoOpLogger, SeverityNumber, get_logger_provider
 from opentelemetry.sdk._logs import (
-    LogDeprecatedInitWarning,
     Logger,
     LoggerProvider,
     LogRecord,
@@ -58,22 +57,17 @@ def emit(self, event: Event) -> None:
             return
         span_context = trace.get_current_span().get_span_context()
 
-        # silence deprecation warnings from internal users
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", category=LogDeprecatedInitWarning)
-
-            log_record = LogRecord(
-                timestamp=event.timestamp or time_ns(),
-                observed_timestamp=None,
-                trace_id=event.trace_id or span_context.trace_id,
-                span_id=event.span_id or span_context.span_id,
-                trace_flags=event.trace_flags or span_context.trace_flags,
-                severity_text=None,
-                severity_number=event.severity_number or SeverityNumber.INFO,
-                body=event.body,
-                resource=getattr(self._logger, "resource", None),
-                attributes=event.attributes,
-            )
+        log_record = LogRecord(
+            timestamp=event.timestamp or time_ns(),
+            observed_timestamp=None,
+            trace_id=event.trace_id or span_context.trace_id,
+            span_id=event.span_id or span_context.span_id,
+            trace_flags=event.trace_flags or span_context.trace_flags,
+            severity_text=None,
+            severity_number=event.severity_number or SeverityNumber.INFO,
+            body=event.body,
+            attributes=event.attributes,
+        )
         self._logger.emit(log_record)
 
 

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

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
+from opentelemetry._logs import LogRecord
 from opentelemetry.sdk._logs._internal import (
     LogDroppedAttributesWarning,
     Logger,
@@ -25,12 +25,13 @@
 )
 
 __all__ = [
+    "LogDroppedAttributesWarning",
     "Logger",
     "LoggerProvider",
     "LoggingHandler",
     "LogLimits",
+    "LogRecord",
     "LogRecordProcessor",
-    "LogDroppedAttributesWarning",
     "ReadableLogRecord",
     "ReadWriteLogRecord",
 ]

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

@@ -78,18 +78,6 @@ class LogDroppedAttributesWarning(UserWarning):
 warnings.simplefilter("once", LogDroppedAttributesWarning)
 
 
-class LogDeprecatedInitWarning(UserWarning):
-    """Custom warning to indicate that deprecated and soon to be deprecated Log classes was used.
-
-    This class is used to filter and handle these specific warnings separately
-    from other warnings, ensuring that they are only shown once without
-    interfering with default user warnings.
-    """
-
-
-warnings.simplefilter("once", LogDeprecatedInitWarning)
-
-
 class LogLimits:
     """This class is based on a SpanLimits class in the Tracing module.
 
@@ -281,6 +269,7 @@ def _from_api_log_record(
             instrumentation_scope=instrumentation_scope,
         )
 
+
 class LogRecordProcessor(abc.ABC):
     """Interface to hook the log record emitting action.
 
@@ -518,7 +507,7 @@ def _get_attributes(record: logging.LogRecord) -> _ExtendedAttributes:
                 )
         return attributes
 
-    def _translate(self, record: logging.LogRecord) -> dict:
+    def _translate(self, record: logging.LogRecord) -> LogRecord:
         timestamp = int(record.created * 1e9)
         observered_timestamp = time_ns()
         attributes = self._get_attributes(record)
@@ -552,15 +541,15 @@ def _translate(self, record: logging.LogRecord) -> dict:
             "WARN" if record.levelname == "WARNING" else record.levelname
         )
 
-        return {
-            "timestamp": timestamp,
-            "observed_timestamp": observered_timestamp,
-            "context": get_current() or None,
-            "severity_text": level_name,
-            "severity_number": severity_number,
-            "body": body,
-            "attributes": attributes,
-        }
+        return LogRecord(
+            timestamp=timestamp,
+            observed_timestamp=observered_timestamp,
+            context=get_current() or None,
+            severity_text=level_name,
+            severity_number=severity_number,
+            body=body,
+            attributes=attributes,
+        )
 
     def emit(self, record: logging.LogRecord) -> None:
         """
@@ -570,7 +559,7 @@ def emit(self, record: logging.LogRecord) -> None:
         """
         logger = get_logger(record.name, logger_provider=self._logger_provider)
         if not isinstance(logger, NoOpLogger):
-            logger.emit(**self._translate(record))
+            logger.emit(self._translate(record))
 
     def flush(self) -> None:
         """
@@ -609,6 +598,7 @@ def __init__(
     def resource(self):
         return self._resource
 
+    # pylint: disable=arguments-differ
     def emit(self, record: LogRecord):
         """Emits the :class:`ReadWriteLogRecord` by setting instrumentation scope
         and forwarding to the processor.

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

@@ -27,7 +27,7 @@
     set_value,
 )
 from opentelemetry.sdk._logs import (
-    LogRecord
+    LogRecord,
     LogRecordProcessor,
     ReadableLogRecord,
     ReadWriteLogRecord,

opentelemetry-sdk/tests/logs/test_log_record.py

@@ -25,7 +25,6 @@
     ReadWriteLogRecord,
 )
 from opentelemetry.sdk.resources import Resource
-from opentelemetry.sdk.util.instrumentation import InstrumentationScope
 from opentelemetry.trace.span import TraceFlags
 
 
@@ -205,9 +204,6 @@ def test_log_record_from_api_log_record(self):
             timestamp=1,
             observed_timestamp=2,
             context=get_current(),
-            trace_id=123,
-            span_id=456,
-            trace_flags=TraceFlags(0x01),
             severity_text="WARN",
             severity_number=SeverityNumber.WARN,
             body="a log line",
@@ -223,9 +219,10 @@ def test_log_record_from_api_log_record(self):
         self.assertEqual(record.log_record.timestamp, 1)
         self.assertEqual(record.log_record.observed_timestamp, 2)
         self.assertEqual(record.log_record.context, get_current())
-        self.assertEqual(record.log_record.trace_id, 123)
-        self.assertEqual(record.log_record.span_id, 456)
-        self.assertEqual(record.log_record.trace_flags, TraceFlags(0x01))
+        # trace_id, span_id, and trace_flags come from the context's span
+        self.assertEqual(record.log_record.trace_id, 0)
+        self.assertEqual(record.log_record.span_id, 0)
+        self.assertEqual(record.log_record.trace_flags, TraceFlags(0x00))
         self.assertEqual(record.log_record.severity_text, "WARN")
         self.assertEqual(
             record.log_record.severity_number, SeverityNumber.WARN
@@ -234,33 +231,3 @@ def test_log_record_from_api_log_record(self):
         self.assertEqual(record.log_record.attributes, {"a": "b"})
         self.assertEqual(record.log_record.event_name, "an.event")
         self.assertEqual(record.resource, resource)
-
-
-class TestLogData(unittest.TestCase):
-    def test_init_deprecated_warning(self):
-        """Test that LogData initialization emits a LogDeprecatedInitWarning."""
-        log_record = LogRecord()
-
-        with warnings.catch_warnings(record=True) as cw:
-            warnings.simplefilter("always")
-            LogData(
-                log_record=log_record,
-                instrumentation_scope=InstrumentationScope("foo", "bar"),
-            )
-
-        # Check that at least one LogDeprecatedInitWarning was emitted
-        init_warnings = [
-            w for w in cw if isinstance(w.message, LogDeprecatedInitWarning)
-        ]
-        self.assertGreater(
-            len(init_warnings),
-            0,
-            "Expected at least one LogDeprecatedInitWarning",
-        )
-
-        # Check the message content of the LogDeprecatedInitWarning
-        warning_message = str(init_warnings[0].message)
-        self.assertIn(
-            "LogData will be removed in 1.39.0 and replaced by ReadWriteLogRecord and ReadableLogRecord",
-            warning_message,
-        )

opentelemetry-sdk/tests/logs/test_logs.py

@@ -17,8 +17,7 @@
 import unittest
 from unittest.mock import Mock, patch
 
-from opentelemetry._logs import LogRecord as APILogRecord
-from opentelemetry._logs import SeverityNumber
+from opentelemetry._logs import LogRecord, SeverityNumber
 from opentelemetry.context import get_current
 from opentelemetry.sdk._logs import (
     Logger,
@@ -178,18 +177,18 @@ def test_can_emit_api_logrecord(self):
         self.assertTrue(isinstance(log_record, LogRecord))
         self.assertEqual(log_record.timestamp, None)
         self.assertEqual(log_record.observed_timestamp, 0)
-        self.assertEqual(log_record.context, {})
+        self.assertIsNotNone(log_record.context)
         self.assertEqual(log_record.severity_number, None)
         self.assertEqual(log_record.severity_text, None)
         self.assertEqual(log_record.body, "a log line")
         self.assertEqual(log_record.attributes, {})
         self.assertEqual(log_record.event_name, None)
-        self.assertEqual(log_record.resource, logger.resource)
+        self.assertEqual(log_data.resource, logger.resource)
 
     def test_can_emit_with_keywords_arguments(self):
         logger, log_record_processor_mock = self._get_logger()
 
-        logger.emit(
+        log_record = LogRecord(
             timestamp=100,
             observed_timestamp=101,
             context=get_current(),
@@ -199,16 +198,19 @@ def test_can_emit_with_keywords_arguments(self):
             attributes={"some": "attributes"},
             event_name="event_name",
         )
+        logger.emit(log_record)
         log_record_processor_mock.on_emit.assert_called_once()
         log_data = log_record_processor_mock.on_emit.call_args.args[0]
-        log_record = log_data.log_record
-        self.assertTrue(isinstance(log_record, LogRecord))
-        self.assertEqual(log_record.timestamp, 100)
-        self.assertEqual(log_record.observed_timestamp, 101)
-        self.assertEqual(log_record.context, {})
-        self.assertEqual(log_record.severity_number, SeverityNumber.WARN)
-        self.assertEqual(log_record.severity_text, "warn")
-        self.assertEqual(log_record.body, "a body")
-        self.assertEqual(log_record.attributes, {"some": "attributes"})
-        self.assertEqual(log_record.event_name, "event_name")
-        self.assertEqual(log_record.resource, logger.resource)
+        result_log_record = log_data.log_record
+        self.assertTrue(isinstance(result_log_record, LogRecord))
+        self.assertEqual(result_log_record.timestamp, 100)
+        self.assertEqual(result_log_record.observed_timestamp, 101)
+        self.assertIsNotNone(result_log_record.context)
+        self.assertEqual(
+            result_log_record.severity_number, SeverityNumber.WARN
+        )
+        self.assertEqual(result_log_record.severity_text, "warn")
+        self.assertEqual(result_log_record.body, "a body")
+        self.assertEqual(result_log_record.attributes, {"some": "attributes"})
+        self.assertEqual(result_log_record.event_name, "event_name")
+        self.assertEqual(log_data.resource, logger.resource)