CG: loguru finalized with documentation

Author: carolinecgilbert

handlers/opentelemetry_loguru/src/README.md

@@ -0,0 +1,53 @@
+# Loguru Handler for OpenTelemetry
+
+This project provides a Loguru handler for OpenTelemetry applications. The handler converts Loguru logs into the OpenTelemetry Logs Protocol (OTLP) format for export to a collector.
+
+## Usage
+
+To use the Loguru handler in your OpenTelemetry application, follow these steps:
+
+1. Import the necessary modules:
+
+```python
+import loguru
+from handlers.opentelemetry_loguru.src.exporter import LoguruHandler
+from opentelemetry.sdk._logs._internal.export import LogExporter
+from opentelemetry.sdk.resources import Resource
+```
+
+2. Initialize the LoguruHandler with your service name, server hostname, and LogExporter instance:
+
+```python
+service_name = "my_service"
+server_hostname = "my_server"
+exporter = LogExporter()  # Initialize your LogExporter instance
+handler = LoguruHandler(service_name, server_hostname, exporter)
+```
+
+3. Add the handler to your Loguru logger:
+
+```python
+logger = loguru.logger
+logger.add(handler.sink)
+```
+
+4. Use the logger as usual with Loguru:
+
+```python
+logger.warning("This is a test log message.")
+```
+## OpenTelemetry Application Example with Handler
+See the loguru handler demo in the examples directory of this repository for a step-by-step guide on using the handler in an OpenTelemetry application.
+
+## Customization
+
+The LoguruHandler supports customization through its constructor parameters:
+
+- `service_name`: The name of your service.
+- `server_hostname`: The hostname of the server where the logs originate.
+- `exporter`: An instance of your LogExporter for exporting logs to a collector.
+
+## Notes
+
+- This handler automatically converts Loguru logs into the OTLP format for compatibility with OpenTelemetry.
+- It extracts attributes from Loguru logs and maps them to OpenTelemetry attributes for log records.

handlers/opentelemetry_loguru/src/exporter.py

@@ -94,30 +94,48 @@
     53: SeverityNumber.FATAL4,
 }
 
-
+EXCLUDE_ATTR = ("elapsed", "exception", "extra", "file", "level", "process", "thread", "time")
 class LoguruHandler:
 
     # this was largely inspired by the OpenTelemetry handler for stdlib `logging`:
     # https://github.com/open-telemetry/opentelemetry-python/blob/8f312c49a5c140c14d1829c66abfe4e859ad8fd7/opentelemetry-sdk/src/opentelemetry/sdk/_logs/_internal/__init__.py#L318
 
     def __init__(
         self,
-        logger_provider=None,
+        service_name: str,
+        server_hostname: str,
+        exporter: LogExporter,
     ) -> None:
-        
-        self._logger_provider = logger_provider or get_logger_provider()
-        self._logger = get_logger(
-            __name__, logger_provider=self._logger_provider
+        logger_provider = LoggerProvider(
+            resource=Resource.create(
+                {
+                    "service.name": service_name,
+                    "service.instance.id": server_hostname,
+                }
+            ),
+        )
+
+        logger_provider.add_log_record_processor(
+            BatchLogRecordProcessor(exporter, max_export_batch_size=1)
         )
+
+        self._logger_provider = logger_provider
+        self._logger = logger_provider.get_logger(__name__)
 
 
     def _get_attributes(self, record) -> Attributes:
-        attributes = {key:value for key, value in record.items()}
+        attributes = {key:value for key, value in record.items() if key not in EXCLUDE_ATTR}
 
          # Add standard code attributes for logs.
-        attributes[SpanAttributes.CODE_FILEPATH] = record['file'] #This includes file and path -> (file, path)
+        attributes[SpanAttributes.CODE_FILEPATH] = record['file'].path #This includes file and path -> (file, path)
         attributes[SpanAttributes.CODE_FUNCTION] = record['function']
         attributes[SpanAttributes.CODE_LINENO] = record['line']
+
+        attributes['process_name'] = (record['process']).name
+        attributes['process_id'] = (record['process']).id
+        attributes['thread_name'] = (record['thread']).name
+        attributes['thread_id'] = (record['thread']).id
+        attributes['file'] = record['file'].name
 
         if record['exception'] is not None:
 
@@ -138,11 +156,13 @@ def _loguru_to_otel(self, levelno: int) -> SeverityNumber:
 
         return _STD_TO_OTEL[levelno]
 
+  
+        
 
     def _translate(self, record) -> LogRecord:
 
         #Timestamp
-        timestamp = record["time"]
+        timestamp = int((record["time"].timestamp()) * 1e9)
 
         #Observed timestamp
         observedTimestamp = time_ns()
@@ -179,6 +199,6 @@ def _translate(self, record) -> LogRecord:
         )
 
     def sink(self, record) -> None:
-        
-        self._logger.emit(self._translate(record))
+        print("\n BALLIN HERE\n")
+        self._logger.emit(self._translate(record.record))
 

handlers/opentelemetry_structlog/src/README.md

@@ -0,0 +1,60 @@
+# Structlog Handler for OpenTelemetry
+This project provides a Structlog handler for OpenTelemetry applications. The handler converts Structlog logs into the OpenTelemetry Logs Protocol (OTLP) format for export to a collector.
+
+## Usage
+
+To use the Structlog handler in your OpenTelemetry application, follow these steps:
+
+1. Import the necessary modules:
+
+```python
+import structlog
+from opentelemetry.sdk._logs._internal.export import LogExporter
+from opentelemetry.sdk.resources import Resource
+from handlers.opentelemetry_structlog.src.exporter import StructlogHandler
+```
+
+2. Initialize the StructlogHandler with your service name, server hostname, and LogExporter instance:
+
+```python
+service_name = "my_service"
+server_hostname = "my_server"
+exporter = LogExporter()  # Initialize your LogExporter instance
+handler = StructlogHandler(service_name, server_hostname, exporter)
+```
+
+3. Add the handler to your Structlog logger:
+
+```python
+structlog.configure(
+    processors=[structlog.processors.JSONRenderer()],
+    logger_factory=structlog.stdlib.LoggerFactory(),
+    wrapper_class=structlog.stdlib.BoundLogger,
+    cache_logger_on_first_use=True,
+    context_class=dict,
+    **handler.wrap_for_structlog(),
+)
+```
+
+4. Use the logger as usual with Structlog:
+
+```python
+logger = structlog.get_logger()
+logger.info("This is a test log message.")
+```
+## OpenTelemetry Application Example with Handler
+See the structlog handler demo in the examples directory of this repository for a step-by-step guide on using the handler in an OpenTelemetry application.
+
+## Customization
+
+The StructlogHandler supports customization through its constructor parameters:
+
+- `service_name`: The name of your service.
+- `server_hostname`: The hostname of the server where the logs originate.
+- `exporter`: An instance of your LogExporter for exporting logs to a collector.
+
+## Notes
+
+- This handler automatically converts the `timestamp` key in the `event_dict` to ISO 8601 format for better compatibility.
+- It performs operations similar to `structlog.processors.ExceptionRenderer`, so avoid using `ExceptionRenderer` in the same pipeline.
+```

instrumentation/opentelemetry-instrumentation-logging/test-requirements.txt

@@ -15,5 +15,6 @@ wrapt==1.16.0
 zipp==3.17.0
 structlog==24.1.0
 loguru==0.7.2
+opentelemetry-exporter-otlp==1.24.0
 -e opentelemetry-instrumentation
 -e instrumentation/opentelemetry-instrumentation-logging

instrumentation/opentelemetry-instrumentation-logging/tests/test_logging.py

@@ -27,7 +27,9 @@
 from datetime import datetime, timezone
 
 from unittest.mock import MagicMock, patch
-
+from opentelemetry.exporter.otlp.proto.grpc._log_exporter import (
+    OTLPLogExporter,
+)
 
 
 from opentelemetry.semconv.trace import SpanAttributes
@@ -389,41 +391,58 @@ def test_trace_context_propogation(self):
 
                 assert log_record.trace_flags == trace_sampled, "Trace flags should be propagated" 
 
-
+class TimestampRecord:
+    def __init__(self, data):
+        self.timestam = data
+    def timestamp(self):
+        return self.timestam
 
 class TestLoguruHandler(TestBase):
     def setUp(self):
         self.default_provider = get_logger_provider()
         self.custom_provider = MagicMock()
+
+        RecordFile = namedtuple('RecordFile', ['path', 'name'])
+        file_record = RecordFile(
+            path="test_file.py",
+            name = "test_file.py"
+        )
+
+        RecordProcess = namedtuple('RecordProcess', ['name', 'id'])
+        process_record = RecordProcess(
+            name = "MainProcess",
+            id = 1
+        )
+
+        RecordThread = namedtuple('RecordThread', ['name', 'id'])
+        thread_record = RecordThread(
+            name = "MainThread",
+            id = 1
+        )
+
+        timeRec = TimestampRecord(data=2.38763786)
+
         self.record = {
-            "time": 1581000000.000123,
+            "time": timeRec,
             "level": MagicMock(name="ERROR", no=40),
             "message": "Test message",
-            "file": "test_file.py",
+            "file": file_record,
+            "process": process_record,
+            "thread": thread_record,
             "function": "test_function",
             "line": 123,
             "exception": None
         }
-        # self.span_context = SpanContext(
-        #     trace_id=1234,
-        #     span_id=5678,
-        #     trace_flags=TraceFlags(1),
-        #     is_remote=False
-        # )
+
         self.span_context = get_current_span().get_span_context()
         self.current_span = MagicMock()
-        self.current_span.get_span_context.return_value = self.span_context
+        self.current_span.get_span_context.return_value = self.span_context 
 
-    def test_initialization_with_default_provider(self):
-        handler = LoguruHandler()
-        self.assertEqual(handler._logger_provider, self.default_provider)
+    def test_attributes_extraction_without_exception(self):
+        handler = LoguruHandler(service_name="flask-loguru-demo", server_hostname="instance-1", exporter=OTLPLogExporter(insecure=True))
 
-    def test_initialization_with_custom_provider(self):
-        handler = LoguruHandler(logger_provider=self.custom_provider)
-        self.assertEqual(handler._logger_provider, self.custom_provider)
+        attrs = handler._get_attributes(self.record)
 
-    def test_attributes_extraction_without_exception(self):
-        attrs = LoguruHandler()._get_attributes(self.record)
         expected_attrs = {
             SpanAttributes.CODE_FILEPATH: 'test_file.py',
             SpanAttributes.CODE_FUNCTION: 'test_function',
@@ -448,11 +467,11 @@ def test_attributes_extraction_with_exception(self, mock_format_exception):
             traceback=mock_format_exception(exception)
         )
         self.record['exception'] = exception_record
-        # self.record['exception'].type = type(exception).__name__
-        # self.record['exception'].value = str(exception)
-        # self.record['exception'].traceback = mock_format_exception(exception)
+
 
-        attrs = LoguruHandler()._get_attributes(self.record)
+        handler = LoguruHandler(service_name="flask-loguru-demo", server_hostname="instance-1", exporter=OTLPLogExporter(insecure=True))
+
+        attrs = handler._get_attributes(self.record)
 
         expected_attrs = {
             SpanAttributes.CODE_FILEPATH: 'test_file.py',
@@ -470,7 +489,9 @@ def test_attributes_extraction_with_exception(self, mock_format_exception):
     @patch('opentelemetry.trace.get_current_span')
     def test_translation(self, mock_get_current_span):
         mock_get_current_span.return_value = self.current_span
-        handler = LoguruHandler(logger_provider=self.custom_provider)
+
+        handler = LoguruHandler(service_name="flask-loguru-demo", server_hostname="instance-1", exporter=OTLPLogExporter(insecure=True))
+        
         log_record = handler._translate(self.record)
         self.assertEqual(log_record.trace_id, self.span_context.trace_id)
         self.assertEqual(log_record.span_id, self.span_context.span_id)
@@ -482,9 +503,14 @@ def test_translation(self, mock_get_current_span):
     @patch('opentelemetry.trace.get_current_span')
     def test_sink(self, mock_get_current_span, mock_emit):
         mock_get_current_span.return_value = self.current_span
-        handler = LoguruHandler(logger_provider=self.custom_provider)
-        handler.sink(self.record)
-        #mock_emit.assert_called_once()
-        handler._logger.emit.assert_called_once()
+        
+        handler = LoguruHandler(service_name="flask-loguru-demo", server_hostname="instance-1", exporter=OTLPLogExporter(insecure=True))
+
+        MessageRecord = namedtuple('MessageRecord', ['record']) 
+        message = MessageRecord(
+            record=self.record
+        )
+
+        handler.sink(message)