Merge branch 'main' into hectorhdzg/removelogdata

Author: hectorhdzg

CHANGELOG.md

@@ -26,6 +26,8 @@ inject a `requests.Session` or `grpc.ChannelCredentials` object into OTLP export
   ([#4731](https://github.com/open-telemetry/opentelemetry-python/pull/4731))
 - Performance: Cache `importlib_metadata.entry_points`
   ([#4735](https://github.com/open-telemetry/opentelemetry-python/pull/4735))
+- opentelemetry-sdk: fix calling Logger.emit with an API LogRecord instance
+  ([#4741](https://github.com/open-telemetry/opentelemetry-python/pull/4741))
 
 ## Version 1.36.0/0.57b0 (2025-07-29)
 

exporter/opentelemetry-exporter-otlp-proto-common/src/opentelemetry/exporter/otlp/proto/common/_internal/_log_encoder/__init__.py

@@ -63,6 +63,9 @@ def _encode_log(readable_log_record: ReadableLogRecord) -> PB2LogRecord:
             readable_log_record.log_record.attributes, allow_null=True
         ),
         dropped_attributes_count=readable_log_record.dropped_attributes,
+        severity_number=getattr(
+            readable_log_record.log_record.severity_number, "value", None
+        ),
         severity_number=readable_log_record.log_record.severity_number.value,
         event_name=readable_log_record.log_record.event_name,
     )

exporter/opentelemetry-exporter-otlp-proto-common/tests/test_log_encoder.py

@@ -88,6 +88,7 @@ def test_dropped_attributes_count(self):
 
     @staticmethod
     def _get_sdk_log_data() -> List[ReadWriteLogRecord]:
+        # pylint:disable=too-many-locals
         ctx_log1 = set_span_in_context(
             NonRecordingSpan(
                 SpanContext(
@@ -303,7 +304,29 @@ def _get_sdk_log_data() -> List[ReadWriteLogRecord]:
                 "extended_name", "extended_version"
             ),
         )
-        return [log1, log2, log3, log4, log5, log6, log7, log8]
+
+        ctx_log9 = set_span_in_context(
+            NonRecordingSpan(
+                SpanContext(
+                    212592107417388365804938480559624925566,
+                    6077757853989569466,
+                    False,
+                    TraceFlags(0x01),
+                )
+            )
+        )
+        log9 = LogData(
+            log_record=SDKLogRecord(
+                # these are otherwise set by default
+                observed_timestamp=1644650584292683045,
+                context=ctx_log9,
+                resource=SDKResource({}),
+            ),
+            instrumentation_scope=InstrumentationScope(
+                "empty_log_record_name", "empty_log_record_version"
+            ),
+        )
+        return [log1, log2, log3, log4, log5, log6, log7, log8, log9]
 
     def get_test_logs(
         self,
@@ -592,6 +615,29 @@ def get_test_logs(
                                 ),
                             ],
                         ),
+                        PB2ScopeLogs(
+                            scope=PB2InstrumentationScope(
+                                name="empty_log_record_name",
+                                version="empty_log_record_version",
+                            ),
+                            log_records=[
+                                PB2LogRecord(
+                                    time_unix_nano=None,
+                                    observed_time_unix_nano=1644650584292683045,
+                                    trace_id=_encode_trace_id(
+                                        212592107417388365804938480559624925566
+                                    ),
+                                    span_id=_encode_span_id(
+                                        6077757853989569466,
+                                    ),
+                                    flags=int(TraceFlags(0x01)),
+                                    severity_text=None,
+                                    severity_number=None,
+                                    body=None,
+                                    attributes=None,
+                                ),
+                            ],
+                        ),
                     ],
                 ),
             ]

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

@@ -248,6 +248,8 @@ def to_json(self, indent: int | None = 4) -> str:
                 ),
                 "dropped_attributes": self.dropped_attributes,
                 "timestamp": ns_to_iso_str(self.log_record.timestamp),
+                if self.log_record.timestamp is not None
+                else None,
                 "observed_timestamp": ns_to_iso_str(
                     self.log_record.observed_timestamp
                 ),
@@ -275,6 +277,25 @@ def dropped_attributes(self) -> int:
             return self.log_record.attributes.dropped
         return 0
 
+    @classmethod
+    def _from_api_log_record(
+        cls, *, record: APILogRecord, resource: Resource
+    ) -> LogRecord:
+        return cls(
+            timestamp=record.timestamp,
+            observed_timestamp=record.observed_timestamp,
+            context=record.context,
+            trace_id=record.trace_id,
+            span_id=record.span_id,
+            trace_flags=record.trace_flags,
+            severity_text=record.severity_text,
+            severity_number=record.severity_number,
+            body=record.body,
+            attributes=record.attributes,
+            event_name=record.event_name,
+            resource=resource,
+        )
+
 
 class LogRecordProcessor(abc.ABC):
     """Interface to hook the log record emitting action.
@@ -608,6 +629,12 @@ def emit(self, record: LogRecord):
         """Emits the :class:`ReadWriteLogRecord` by setting instrumentation scope
         and forwarding to the processor.
         """
+        if not isinstance(record, ReadWriteLogRecord):
+            # pylint:disable=protected-access
+            record = LogRecord._from_api_log_record(
+            record=record, resource=self._resource
+        )
+            
         log_record = ReadWriteLogRecord(
             log_record=record,
             resource=self._resource,

opentelemetry-sdk/tests/logs/test_log_record.py

@@ -63,6 +63,16 @@ def test_log_record_to_json_serializes_severity_number_as_int(self):
         decoded = json.loads(actual.to_json())
         self.assertEqual(SeverityNumber.WARN.value, decoded["severity_number"])
 
+    def test_log_record_to_json_serializes_null_severity_number(self):
+        actual = LogRecord(
+            observed_timestamp=0,
+            body="a log line",
+            resource=Resource({"service.name": "foo"}),
+        )
+
+        decoded = json.loads(actual.to_json())
+        self.assertEqual(None, decoded["timestamp"])
+
     def test_log_record_bounded_attributes(self):
         attr = {"key": "value"}
 
@@ -172,3 +182,62 @@ def test_log_record_dropped_attributes_unset_limits(self):
         )
         self.assertTrue(result.dropped_attributes == 0)
         self.assertEqual(attr, result.log_record.attributes)
+
+    def test_log_record_deprecated_init_warning(self):
+        test_cases = [
+            {"trace_id": 123},
+            {"span_id": 123},
+            {"trace_flags": TraceFlags(0x01)},
+        ]
+
+        for params in test_cases:
+            with self.subTest(params=params):
+                with warnings.catch_warnings(record=True) as cw:
+                    for _ in range(10):
+                        LogRecord(**params)
+
+                self.assertEqual(len(cw), 1)
+                self.assertIsInstance(cw[-1].message, LogDeprecatedInitWarning)
+                self.assertIn(
+                    "LogRecord init with `trace_id`, `span_id`, and/or `trace_flags` is deprecated since 1.35.0. Use `context` instead.",
+                    str(cw[-1].message),
+                )
+
+        with warnings.catch_warnings(record=True) as cw:
+            for _ in range(10):
+                LogRecord(context=get_current())
+        self.assertEqual(len(cw), 0)
+
+    # pylint:disable=protected-access
+    def test_log_record_from_api_log_record(self):
+        api_log_record = APILogRecord(
+            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",
+            attributes={"a": "b"},
+            event_name="an.event",
+        )
+
+        resource = Resource.create({})
+        record = LogRecord._from_api_log_record(
+            record=api_log_record, resource=resource
+        )
+
+        self.assertEqual(record.timestamp, 1)
+        self.assertEqual(record.observed_timestamp, 2)
+        self.assertEqual(record.context, get_current())
+        self.assertEqual(record.trace_id, 123)
+        self.assertEqual(record.span_id, 456)
+        self.assertEqual(record.trace_flags, TraceFlags(0x01))
+        self.assertEqual(record.severity_text, "WARN")
+        self.assertEqual(record.severity_number, SeverityNumber.WARN)
+        self.assertEqual(record.body, "a log line")
+        self.assertEqual(record.attributes, {"a": "b"})
+        self.assertEqual(record.event_name, "an.event")
+        self.assertEqual(record.resource, resource)

opentelemetry-sdk/tests/logs/test_logs.py

@@ -25,6 +25,7 @@
 )
 from opentelemetry.sdk.environment_variables import OTEL_SDK_DISABLED
 from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.util.instrumentation import InstrumentationScope
 
 
 class TestLoggerProvider(unittest.TestCase):
@@ -87,7 +88,6 @@ def test_logger_provider_init(self, resource_patch):
         )
         self.assertIsNotNone(logger_provider._at_exit_handler)
 
-
 class TestReadableLogRecord(unittest.TestCase):
     def setUp(self):
         self.log_record = LogRecord(
@@ -127,3 +127,42 @@ def test_readable_log_record_can_read_attributes(self):
             self.readable_log_record.resource.attributes["service.name"],
             "test-service",
         )
+
+class TestLogger(unittest.TestCase):
+    @staticmethod
+    def _get_logger():
+        log_record_processor_mock = Mock()
+        logger = Logger(
+            resource=Resource.create({}),
+            multi_log_record_processor=log_record_processor_mock,
+            instrumentation_scope=InstrumentationScope(
+                "name",
+                "version",
+                "schema_url",
+                {"an": "attribute"},
+            ),
+        )
+        return logger, log_record_processor_mock
+
+    def test_can_emit_logrecord(self):
+        logger, log_record_processor_mock = self._get_logger()
+        log_record = LogRecord(
+            observed_timestamp=0,
+            body="a log line",
+        )
+
+        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]
+        self.assertTrue(isinstance(log_data.log_record, LogRecord))
+
+    def test_can_emit_api_logrecord(self):
+        logger, log_record_processor_mock = self._get_logger()
+        api_log_record = APILogRecord(
+            observed_timestamp=0,
+            body="a log line",
+        )
+        logger.emit(api_log_record)
+        log_record_processor_mock.on_emit.assert_called_once()
+        log_data = log_record_processor_mock.on_emit.call_args.args[0]
+        self.assertTrue(isinstance(log_data.log_record, LogRecord))