opentelemetry-sdk: convert an API LogRecord into a LogRecord in Logger.emit

So that the layers below would not care about any difference.

Author: xrmx

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

@@ -337,6 +337,19 @@ def dropped_attributes(self) -> int:
             return attributes.dropped
         return 0
 
+    @classmethod
+    def from_api_log_record(cls, record: APILogRecord) -> LogRecord:
+        return cls(
+            timestamp=record.timestamp,
+            observed_timestamp=record.observed_timestamp,
+            context=record.context,
+            severity_text=record.severity_text,
+            severity_number=record.severity_number,
+            body=record.body,
+            attributes=record.attributes,
+            event_name=record.event_name,
+        )
+
 
 class LogData:
     """Readable LogRecord data plus associated InstrumentationLibrary."""
@@ -680,10 +693,12 @@ def __init__(
     def resource(self):
         return self._resource
 
-    def emit(self, record: LogRecord):
+    def emit(self, record: LogRecord | APILogRecord):
         """Emits the :class:`LogData` by associating :class:`LogRecord`
         and instrumentation info.
         """
+        if isinstance(record, APILogRecord):
+            record = LogRecord.from_api_log_record(record)
         log_data = LogData(record, self._instrumentation_scope)
         self._multi_log_record_processor.on_emit(log_data)
 

opentelemetry-sdk/tests/logs/test_log_record.py

@@ -16,6 +16,7 @@
 import unittest
 import warnings
 
+from opentelemetry._logs import LogRecord as APILogRecord
 from opentelemetry._logs.severity import SeverityNumber
 from opentelemetry.attributes import BoundedAttributes
 from opentelemetry.context import get_current
@@ -182,3 +183,26 @@ def test_log_record_deprecated_init_warning(self):
             for _ in range(10):
                 LogRecord(context=get_current())
         self.assertEqual(len(cw), 0)
+
+    def test_log_record_from_api_log_record(self):
+        api_log_record = APILogRecord(
+            timestamp=1,
+            observed_timestamp=2,
+            context=get_current(),
+            severity_text="WARN",
+            severity_number=SeverityNumber.WARN,
+            body="a log line",
+            attributes={"a": "b"},
+            event_name="an.event",
+        )
+
+        record = LogRecord.from_api_log_record(api_log_record)
+
+        self.assertEqual(record.timestamp, 1)
+        self.assertEqual(record.observed_timestamp, 2)
+        self.assertEqual(record.context, get_current())
+        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")

opentelemetry-sdk/tests/logs/test_logs.py

@@ -17,13 +17,15 @@
 import unittest
 from unittest.mock import Mock, patch
 
-from opentelemetry.sdk._logs import LoggerProvider
+from opentelemetry._logs import LogRecord as APILogRecord
+from opentelemetry.sdk._logs import Logger, LoggerProvider, LogRecord
 from opentelemetry.sdk._logs._internal import (
     NoOpLogger,
     SynchronousMultiLogRecordProcessor,
 )
 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):
@@ -85,3 +87,43 @@ def test_logger_provider_init(self, resource_patch):
             )
         )
         self.assertIsNotNone(logger_provider._at_exit_handler)
+
+
+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))