otel-utils 0.1.18__tar.gz → 0.1.19__tar.gz

{otel_utils-0.1.18 → otel_utils-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: otel-utils
-Version: 0.1.18
+Version: 0.1.19
 Summary: Utilidades simplificadas para instrumentación con OpenTelemetry
 License: Proprietary
 Author: Harold Portocarrero

{otel_utils-0.1.18 → otel_utils-0.1.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "otel-utils"
-version = "0.1.18"
+version = "0.1.19"
 description = "Utilidades simplificadas para instrumentación con OpenTelemetry"
 authors = ["Harold Portocarrero <harold@getcometa.com>"]
 readme = "README.md"

{otel_utils-0.1.18 → otel_utils-0.1.19}/src/otel_utils/configurator.py

@@ -20,6 +20,8 @@ from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 
+from otel_utils.logging import JsonFormatter, StructuredLogger
+
 
 @dataclass
 class OtelConfig:
@@ -33,6 +35,7 @@ class OtelConfig:
     metric_export_interval_ms: int = 30000
     log_level: int = logging.INFO
     enable_console_logging: bool = True
+    json_logging: bool = True
 
     @property
     def trace_endpoint(self) -> Optional[str]:
@@ -143,20 +146,34 @@ class OtelConfigurator:
 
         if self.config.enable_console_logging:
             console_handler = logging.StreamHandler()
-            formatter = logging.Formatter(
-                '[%(asctime)s] %(levelname)s [%(name)s] [trace_id=%(otelTraceID)s span_id=%(otelSpanID)s] - %(message)s',
-                datefmt='%Y-%m-%d %H:%M:%S'
-            )
+
+            if self.config.json_logging:
+                formatter = JsonFormatter()
+            else:
+                formatter = logging.Formatter(
+                    '[%(asctime)s] %(levelname)s [%(name)s] [trace_id=%(otelTraceID)s span_id=%(otelSpanID)s] - %(message)s',
+                    datefmt='%Y-%m-%d %H:%M:%S'
+                )
+
             console_handler.setFormatter(formatter)
             root_logger.addHandler(console_handler)
             root_logger.setLevel(self.config.log_level)
 
         LoggingInstrumentor().instrument(
             logger_provider=logger_provider,
-            set_logging_format=True,
+            set_logging_format=False,
             log_level=self.config.log_level,
             tracer_provider=trace.get_tracer_provider(),
             meter_provider=metrics.get_meter_provider(),
         )
 
-        self.logger = logging.getLogger(self.config.service_name)
+        self.structured_logger = StructuredLogger(self.config.service_name)
+        self.logger = self.structured_logger.logger
+
+
+def get_logger(service_name: str = None, config: OtelConfig = None) -> StructuredLogger:
+    if config:
+        configurator = OtelConfigurator(config)
+        return configurator.structured_logger
+
+    return StructuredLogger(service_name or "default-service")

{otel_utils-0.1.18 → otel_utils-0.1.19}/src/otel_utils/logging.py

@@ -1,6 +1,5 @@
 import json
 import logging
-import platform
 from contextlib import contextmanager
 from datetime import datetime
 from typing import Any, Dict, Optional
@@ -9,22 +8,27 @@ from opentelemetry import trace
 
 
 class JsonFormatter(logging.Formatter):
+
     def format(self, record):
-        log_data = {}
+        log_record = {"timestamp": datetime.utcnow().isoformat(), "level": record.levelname, "logger": record.name,
+                      "message": record.getMessage()}
+
+        if hasattr(record, "otelTraceID"):
+            log_record["trace_id"] = getattr(record, "otelTraceID")
+        if hasattr(record, "otelSpanID"):
+            log_record["span_id"] = getattr(record, "otelSpanID")
 
-        if hasattr(record, 'structured') and record.structured:
-            for key, value in record.__dict__.items():
-                if key not in (
-                        'args', 'exc_info', 'exc_text', 'msg', 'message', 'levelname',
-                        'levelno', 'pathname', 'filename', 'module', 'stack_info',
-                        'lineno', 'funcName', 'created', 'msecs', 'relativeCreated',
-                        'name', 'thread', 'threadName', 'processName', 'process'
-                ):
-                    log_data[key] = value
+        if hasattr(record, "context") and record.context:
+            log_record["context"] = record.context
 
-        log_data['message'] = record.getMessage()
+        if hasattr(record, "operation"):
+            log_record["operation"] = record.operation
 
-        return json.dumps(log_data)
+        for attr in ["service_name", "status", "error_type", "error_message"]:
+            if hasattr(record, attr):
+                log_record[attr] = getattr(record, attr)
+
+        return json.dumps(log_record)
 
 
 class StructuredLogger:
@@ -38,13 +42,10 @@ class StructuredLogger:
             default_attributes: Optional[Dict[str, Any]] = None
     ):
         self.logger = logging.getLogger(service_name)
-        self.default_attributes = {
-            "service.name": service_name,
-            "host.name": platform.node(),
-            **(default_attributes or {})
-        }
+        self.service_name = service_name
+        self.default_attributes = default_attributes or {}
 
-        if not self.logger.handlers or not any(isinstance(h.formatter, JsonFormatter) for h in self.logger.handlers):
+        if not self.logger.handlers:
             handler = logging.StreamHandler()
             handler.setFormatter(JsonFormatter())
             self.logger.addHandler(handler)
@@ -69,40 +70,30 @@ class StructuredLogger:
             *args,
             **kwargs
     ):
-        trace_context = self._get_trace_context()
+        operation = kwargs.pop("operation", None)
+        status = kwargs.pop("status", None)
 
-        log_attributes = {
-            **self.default_attributes,
-            "timestamp": datetime.utcnow().isoformat(),
-            "severity": logging.getLevelName(level),
-            "logger.name": self.logger.name
-        }
+        context = kwargs.copy() if kwargs else None
 
-        if trace_context:
-            log_attributes["trace_id"] = trace_context.get("trace_id")
-            log_attributes["span_id"] = trace_context.get("span_id")
+        extra_data = {
+            "service_name": self.service_name
+        }
 
-        operation = kwargs.pop("operation", None)
         if operation:
-            log_attributes["operation"] = operation
+            extra_data["operation"] = operation
 
-        status = kwargs.pop("status", None)
         if status:
-            log_attributes["status"] = status
-
-        if kwargs:
-            log_attributes["context"] = kwargs
-
-        self.logger.log(
-            level,
-            message,
-            extra={
-                "structured": True,
-                "otel.name": "log",
-                "otel.kind": "event",
-                **log_attributes
-            }
-        )
+            extra_data["status"] = status
+
+        if context:
+            extra_data["context"] = context
+
+        trace_ctx = self._get_trace_context()
+        if trace_ctx:
+            extra_data["otelTraceID"] = trace_ctx.get("trace_id")
+            extra_data["otelSpanID"] = trace_ctx.get("span_id")
+
+        self.logger.log(level, message, extra=extra_data)
 
     def debug(self, message: str, *args, **kwargs):
         self._log(logging.DEBUG, message, *args, **kwargs)
@@ -110,6 +101,9 @@ class StructuredLogger:
     def info(self, message: str, *args, **kwargs):
         self._log(logging.INFO, message, *args, **kwargs)
 
+    def warning(self, message: str, *args, **kwargs):
+        self._log(logging.WARN, message, *args, **kwargs)
+
     def error(self, message: str, *args, **kwargs):
         self._log(logging.ERROR, message, *args, **kwargs)