.

Author: sentrivana

sentry_sdk/integrations/loguru.py

@@ -1,12 +1,10 @@
 import enum
-import functools
 
 import sentry_sdk
 from sentry_sdk.integrations import Integration, DidNotEnable
 from sentry_sdk.integrations.logging import (
     BreadcrumbHandler,
     EventHandler,
-    SentryLogsHandler,
     _BaseHandler,
     _python_level_to_otel,
 )
@@ -15,13 +13,12 @@
 
 if TYPE_CHECKING:
     from logging import LogRecord
-    from typing import Optional, Any
+    from typing import Optional, Any, Tuple
 
 try:
     import loguru
     from loguru import logger
     from loguru._defaults import LOGURU_FORMAT as DEFAULT_FORMAT
-    from loguru._logger import Logger
 except ImportError:
     raise DidNotEnable("LOGURU is not installed")
 
@@ -36,6 +33,10 @@ class LoggingLevels(enum.IntEnum):
     CRITICAL = 50
 
 
+DEFAULT_LEVEL = LoggingLevels.INFO.value
+DEFAULT_EVENT_LEVEL = LoggingLevels.ERROR.value
+
+
 SENTRY_LEVEL_FROM_LOGURU_LEVEL = {
     "TRACE": "DEBUG",
     "DEBUG": "DEBUG",
@@ -46,8 +47,22 @@ class LoggingLevels(enum.IntEnum):
     "CRITICAL": "CRITICAL",
 }
 
-DEFAULT_LEVEL = LoggingLevels.INFO.value
-DEFAULT_EVENT_LEVEL = LoggingLevels.ERROR.value
+
+def _loguru_level_to_otel(record_level):
+    # type: (int) -> Tuple[int, str]
+    for py_level, otel_severity_number, otel_severity_text in [
+        (LoggingLevels.CRITICAL, 21, "fatal"),
+        (LoggingLevels.ERROR, 17, "error"),
+        (LoggingLevels.WARNING, 13, "warn"),
+        (LoggingLevels.SUCCESS, 11, "info"),
+        (LoggingLevels.INFO, 9, "info"),
+        (LoggingLevels.DEBUG, 5, "debug"),
+        (LoggingLevels.TRACE, 1, "trace"),
+    ]:
+        if record_level >= py_level:
+            return otel_severity_number, otel_severity_text
+
+    return 0, "default"
 
 
 class LoguruIntegration(Integration):
@@ -91,24 +106,10 @@ def setup_once():
             )
 
         if LoguruIntegration.sentry_logs_level is not None:
-            #logger.add(
-            #    LoguruSentryLogsHandler(level=LoguruIntegration.sentry_logs_level),
-            #    level=LoguruIntegration.sentry_logs_level,
-            #    format=LoguruIntegration.event_format,
-            #)
-
-            original_log = Logger._log
-
-            @functools.wraps(original_log)
-            def _sentry_patched_log(self, *args, **kwargs):
-                print('hello from senry patched')
-                log_args = args[4]
-                if log_args:
-                    pass
-                result = original_log(self, *args, **kwargs)
-                return result
-
-            Logger._log = _sentry_patched_log
+            logger.add(
+                loguru_sentry_logs_handler,
+                level=LoguruIntegration.sentry_logs_level,
+            )
 
 
 class _LoguruBaseHandler(_BaseHandler):
@@ -133,62 +134,73 @@ def _logging_to_event_level(self, record):
 
 class LoguruEventHandler(_LoguruBaseHandler, EventHandler):
     """Modified version of :class:`sentry_sdk.integrations.logging.EventHandler` to use loguru's level names."""
+
     pass
 
 
 class LoguruBreadcrumbHandler(_LoguruBaseHandler, BreadcrumbHandler):
     """Modified version of :class:`sentry_sdk.integrations.logging.BreadcrumbHandler` to use loguru's level names."""
+
     pass
 
 
-def _loguru_level_to_otel(record_level):
-    # type: (int) -> Tuple[int, str]
-    for py_level, otel_severity_number, otel_severity_text in [
-        (50, 21, "fatal"),
-        (40, 17, "error"),
-        (30, 13, "warn"),
-        (25, 11, "info"),  # Loguru's success
-        (20, 9, "info"),
-        (10, 5, "debug"),
-        (5, 1, "trace"),
-    ]:
-        if record_level >= py_level:
-            return otel_severity_number, otel_severity_text
-    return 0, "default"
+def loguru_sentry_logs_handler(message):
+    client = sentry_sdk.get_client()
+
+    if not client.is_active():
+        return
+
+    if not client.options["_experiments"].get("enable_logs", False):
+        return
+
+    record = message.record
+
+    if record["level"].no < LoguruIntegration.sentry_logs_level:
+        return
+
+    scope = sentry_sdk.get_current_scope()
 
+    otel_severity_number, otel_severity_text = _python_level_to_otel(record["level"].no)
 
-class LoguruSentryLogsHandler(_LoguruBaseHandler):
-    """Modified version of :class:`sentry_sdk.integrations.logging.SentryLogsHandler` to use loguru's level names."""
-    def emit(self, record):
-        client = sentry_sdk.get_client()
+    attrs = {
+        "sentry.origin": "auto.logger.loguru",
+    }
 
-        if not client.is_active():
-            return
+    project_root = client.options["project_root"]
+    if record.get("file"):
+        if project_root is not None and record["file"].path.startswith(project_root):
+            attrs["code.file.path"] = record["file"].path
+        else:
+            attrs["code.file.path"] = record["file"].path
 
-        if not client.options["_experiments"].get("enable_logs", False):
-            return
+    if record.get("line") is not None:
+        attrs["code.line.number"] = record["line"]
 
-        print('rec', record)
-        print('strofrec', str(record))
+    if record.get("function"):
+        attrs["code.function.name"] = record["function"]
 
-        self._capture_log_from_record(client, record)
+    if record.get("thread"):
+        attrs["thread.name"] = record["thread"].name
+        attrs["thread.id"] = record["thread"].id
 
-    def _capture_log_from_record(self, client, record):
-        # type: (BaseClient, LogRecord)
-        scope = sentry_sdk.get_current_scope()
+    if record.get("process"):
+        attrs["process.pid"] = record["process"].id
+        attrs["process.executable.name"] = record["process"].name
 
-        otel_severity_number, otel_severity_text = _python_level_to_otel(record.levelno)
+    if record.get("name"):
+        attrs["logger.name"] = record["name"]
 
-        attrs = {}
+    if record["message"]:
+        attrs["sentry.message.template"] = record["message"]
 
-        client._capture_experimental_log(
-            scope,
-            {
-                "severity_text": otel_severity_text,
-                "severity_number": otel_severity_number,
-                "body": record.msg,
-                "attributes": attrs,
-                "time_unix_nano": int(record.created * 1e9),
-                "trace_id": None,
-            },
-        )
+    client._capture_experimental_log(
+        scope,
+        {
+            "severity_text": otel_severity_text,
+            "severity_number": otel_severity_number,
+            "body": record["message"],
+            "attributes": attrs,
+            "time_unix_nano": int(record["time"].timestamp() * 1e9),
+            "trace_id": None,
+        },
+    )