sentry-sdk 3.0.0a1__py2.py3-none-any.whl → 3.0.0a3__py2.py3-none-any.whl

sentry_sdk/integrations/litestar.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from collections.abc import Set
 import sentry_sdk
 from sentry_sdk.consts import OP, TransactionSource, SOURCE_FOR_STYLE
@@ -52,13 +53,12 @@ class LitestarIntegration(Integration):
 
     def __init__(
         self,
-        failed_request_status_codes=_DEFAULT_FAILED_REQUEST_STATUS_CODES,  # type: Set[int]
+        failed_request_status_codes: Set[int] = _DEFAULT_FAILED_REQUEST_STATUS_CODES,
     ) -> None:
         self.failed_request_status_codes = failed_request_status_codes
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         patch_app_init()
         patch_middlewares()
         patch_http_route_handle()
@@ -75,8 +75,9 @@ class LitestarIntegration(Integration):
 
 
 class SentryLitestarASGIMiddleware(SentryAsgiMiddleware):
-    def __init__(self, app, span_origin=LitestarIntegration.origin):
-        # type: (ASGIApp, str) -> None
+    def __init__(
+        self, app: ASGIApp, span_origin: str = LitestarIntegration.origin
+    ) -> None:
 
         super().__init__(
             app=app,
@@ -86,9 +87,16 @@ class SentryLitestarASGIMiddleware(SentryAsgiMiddleware):
             span_origin=span_origin,
         )
 
+    def _capture_request_exception(self, exc: Exception) -> None:
+        """Avoid catching exceptions from request handlers.
+
+        Those exceptions are already handled in Litestar.after_exception handler.
+        We still catch exceptions from application lifespan handlers.
+        """
+        pass
+
 
-def patch_app_init():
-    # type: () -> None
+def patch_app_init() -> None:
     """
     Replaces the Litestar class's `__init__` function in order to inject `after_exception` handlers and set the
     `SentryLitestarASGIMiddleware` as the outmost middleware in the stack.
@@ -99,8 +107,7 @@ def patch_app_init():
     old__init__ = Litestar.__init__
 
     @ensure_integration_enabled(LitestarIntegration, old__init__)
-    def injection_wrapper(self, *args, **kwargs):
-        # type: (Litestar, *Any, **Any) -> None
+    def injection_wrapper(self: Litestar, *args: Any, **kwargs: Any) -> None:
         kwargs["after_exception"] = [
             exception_handler,
             *(kwargs.get("after_exception") or []),
@@ -114,13 +121,11 @@ def patch_app_init():
     Litestar.__init__ = injection_wrapper
 
 
-def patch_middlewares():
-    # type: () -> None
+def patch_middlewares() -> None:
     old_resolve_middleware_stack = BaseRouteHandler.resolve_middleware
 
     @ensure_integration_enabled(LitestarIntegration, old_resolve_middleware_stack)
-    def resolve_middleware_wrapper(self):
-        # type: (BaseRouteHandler) -> list[Middleware]
+    def resolve_middleware_wrapper(self: BaseRouteHandler) -> list[Middleware]:
         return [
             enable_span_for_middleware(middleware)
             for middleware in old_resolve_middleware_stack(self)
@@ -129,8 +134,7 @@ def patch_middlewares():
     BaseRouteHandler.resolve_middleware = resolve_middleware_wrapper
 
 
-def enable_span_for_middleware(middleware):
-    # type: (Middleware) -> Middleware
+def enable_span_for_middleware(middleware: Middleware) -> Middleware:
     if (
         not hasattr(middleware, "__call__")  # noqa: B004
         or middleware is SentryLitestarASGIMiddleware
@@ -138,12 +142,13 @@ def enable_span_for_middleware(middleware):
         return middleware
 
     if isinstance(middleware, DefineMiddleware):
-        old_call = middleware.middleware.__call__  # type: ASGIApp
+        old_call: ASGIApp = middleware.middleware.__call__
     else:
         old_call = middleware.__call__
 
-    async def _create_span_call(self, scope, receive, send):
-        # type: (MiddlewareProtocol, LitestarScope, Receive, Send) -> None
+    async def _create_span_call(
+        self: MiddlewareProtocol, scope: LitestarScope, receive: Receive, send: Send
+    ) -> None:
         if sentry_sdk.get_client().get_integration(LitestarIntegration) is None:
             return await old_call(self, scope, receive, send)
 
@@ -157,8 +162,9 @@ def enable_span_for_middleware(middleware):
             middleware_span.set_tag("litestar.middleware_name", middleware_name)
 
             # Creating spans for the "receive" callback
-            async def _sentry_receive(*args, **kwargs):
-                # type: (*Any, **Any) -> Union[HTTPReceiveMessage, WebSocketReceiveMessage]
+            async def _sentry_receive(
+                *args: Any, **kwargs: Any
+            ) -> Union[HTTPReceiveMessage, WebSocketReceiveMessage]:
                 if sentry_sdk.get_client().get_integration(LitestarIntegration) is None:
                     return await receive(*args, **kwargs)
                 with sentry_sdk.start_span(
@@ -175,8 +181,7 @@ def enable_span_for_middleware(middleware):
             new_receive = _sentry_receive if not receive_patched else receive
 
             # Creating spans for the "send" callback
-            async def _sentry_send(message):
-                # type: (Message) -> None
+            async def _sentry_send(message: Message) -> None:
                 if sentry_sdk.get_client().get_integration(LitestarIntegration) is None:
                     return await send(message)
                 with sentry_sdk.start_span(
@@ -205,19 +210,19 @@ def enable_span_for_middleware(middleware):
     return middleware
 
 
-def patch_http_route_handle():
-    # type: () -> None
+def patch_http_route_handle() -> None:
     old_handle = HTTPRoute.handle
 
-    async def handle_wrapper(self, scope, receive, send):
-        # type: (HTTPRoute, HTTPScope, Receive, Send) -> None
+    async def handle_wrapper(
+        self: HTTPRoute, scope: HTTPScope, receive: Receive, send: Send
+    ) -> None:
         if sentry_sdk.get_client().get_integration(LitestarIntegration) is None:
             return await old_handle(self, scope, receive, send)
 
         sentry_scope = sentry_sdk.get_isolation_scope()
-        request = scope["app"].request_class(
+        request: Request[Any, Any] = scope["app"].request_class(
             scope=scope, receive=receive, send=send
-        )  # type: Request[Any, Any]
+        )
         extracted_request_data = ConnectionDataExtractor(
             parse_body=True, parse_query=True
         )(request)
@@ -225,8 +230,7 @@ def patch_http_route_handle():
 
         request_data = await body
 
-        def event_processor(event, _):
-            # type: (Event, Hint) -> Event
+        def event_processor(event: Event, _: Hint) -> Event:
             route_handler = scope.get("route_handler")
 
             request_info = event.get("request", {})
@@ -270,8 +274,7 @@ def patch_http_route_handle():
     HTTPRoute.handle = handle_wrapper
 
 
-def retrieve_user_from_scope(scope):
-    # type: (LitestarScope) -> Optional[dict[str, Any]]
+def retrieve_user_from_scope(scope: LitestarScope) -> Optional[dict[str, Any]]:
     scope_user = scope.get("user")
     if isinstance(scope_user, dict):
         return scope_user
@@ -282,9 +285,8 @@ def retrieve_user_from_scope(scope):
 
 
 @ensure_integration_enabled(LitestarIntegration)
-def exception_handler(exc, scope):
-    # type: (Exception, LitestarScope) -> None
-    user_info = None  # type: Optional[dict[str, Any]]
+def exception_handler(exc: Exception, scope: LitestarScope) -> None:
+    user_info: Optional[dict[str, Any]] = None
     if should_send_default_pii():
         user_info = retrieve_user_from_scope(scope)
     if user_info and isinstance(user_info, dict):

sentry_sdk/integrations/logging.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 import sys
 from datetime import datetime, timezone
@@ -5,6 +6,7 @@ from fnmatch import fnmatch
 
 import sentry_sdk
 from sentry_sdk.client import BaseClient
+from sentry_sdk.logger import _log_level_to_otel
 from sentry_sdk.utils import (
     safe_repr,
     to_string,
@@ -14,7 +16,7 @@ from sentry_sdk.utils import (
 )
 from sentry_sdk.integrations import Integration
 
-from typing import TYPE_CHECKING, Tuple
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from collections.abc import MutableMapping
@@ -36,6 +38,16 @@ LOGGING_TO_EVENT_LEVEL = {
     logging.CRITICAL: "fatal",  # CRITICAL is same as FATAL
 }
 
+# Map logging level numbers to corresponding OTel level numbers
+SEVERITY_TO_OTEL_SEVERITY = {
+    logging.CRITICAL: 21,  # fatal
+    logging.ERROR: 17,  # error
+    logging.WARNING: 13,  # warn
+    logging.INFO: 9,  # info
+    logging.DEBUG: 5,  # debug
+}
+
+
 # Capturing events from those loggers causes recursion errors. We cannot allow
 # the user to unconditionally create events from those loggers under any
 # circumstances.
@@ -53,9 +65,8 @@ _IGNORED_LOGGERS = set(
 
 
 def ignore_logger(
-    name,  # type: str
-):
-    # type: (...) -> None
+    name: str,
+) -> None:
     """This disables recording (both in breadcrumbs and as events) calls to
     a logger of a specific name.  Among other uses, many of our integrations
     use this to prevent their actions being recorded as breadcrumbs. Exposed
@@ -71,11 +82,10 @@ class LoggingIntegration(Integration):
 
     def __init__(
         self,
-        level=DEFAULT_LEVEL,
-        event_level=DEFAULT_EVENT_LEVEL,
-        sentry_logs_level=DEFAULT_LEVEL,
-    ):
-        # type: (Optional[int], Optional[int], Optional[int]) -> None
+        level: Optional[int] = DEFAULT_LEVEL,
+        event_level: Optional[int] = DEFAULT_EVENT_LEVEL,
+        sentry_logs_level: Optional[int] = DEFAULT_LEVEL,
+    ) -> None:
         self._handler = None
         self._breadcrumb_handler = None
         self._sentry_logs_handler = None
@@ -89,8 +99,7 @@ class LoggingIntegration(Integration):
         if event_level is not None:
             self._handler = EventHandler(level=event_level)
 
-    def _handle_record(self, record):
-        # type: (LogRecord) -> None
+    def _handle_record(self, record: LogRecord) -> None:
         if self._handler is not None and record.levelno >= self._handler.level:
             self._handler.handle(record)
 
@@ -107,12 +116,10 @@ class LoggingIntegration(Integration):
             self._sentry_logs_handler.handle(record)
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         old_callhandlers = logging.Logger.callHandlers
 
-        def sentry_patched_callhandlers(self, record):
-            # type: (Any, LogRecord) -> Any
+        def sentry_patched_callhandlers(self: Any, record: LogRecord) -> Any:
             # keeping a local reference because the
             # global might be discarded on shutdown
             ignored_loggers = _IGNORED_LOGGERS
@@ -124,7 +131,10 @@ class LoggingIntegration(Integration):
                 # the integration.  Otherwise we have a high chance of getting
                 # into a recursion error when the integration is resolved
                 # (this also is slower).
-                if ignored_loggers is not None and record.name not in ignored_loggers:
+                if (
+                    ignored_loggers is not None
+                    and record.name.strip() not in ignored_loggers
+                ):
                     integration = sentry_sdk.get_client().get_integration(
                         LoggingIntegration
                     )
@@ -165,22 +175,19 @@ class _BaseHandler(logging.Handler):
         )
     )
 
-    def _can_record(self, record):
-        # type: (LogRecord) -> bool
+    def _can_record(self, record: LogRecord) -> bool:
         """Prevents ignored loggers from recording"""
         for logger in _IGNORED_LOGGERS:
-            if fnmatch(record.name, logger):
+            if fnmatch(record.name.strip(), logger):
                 return False
         return True
 
-    def _logging_to_event_level(self, record):
-        # type: (LogRecord) -> str
+    def _logging_to_event_level(self, record: LogRecord) -> str:
         return LOGGING_TO_EVENT_LEVEL.get(
             record.levelno, record.levelname.lower() if record.levelname else ""
         )
 
-    def _extra_from_record(self, record):
-        # type: (LogRecord) -> MutableMapping[str, object]
+    def _extra_from_record(self, record: LogRecord) -> MutableMapping[str, object]:
         return {
             k: v
             for k, v in vars(record).items()
@@ -196,14 +203,12 @@ class EventHandler(_BaseHandler):
     Note that you do not have to use this class if the logging integration is enabled, which it is by default.
     """
 
-    def emit(self, record):
-        # type: (LogRecord) -> Any
+    def emit(self, record: LogRecord) -> Any:
         with capture_internal_exceptions():
             self.format(record)
             return self._emit(record)
 
-    def _emit(self, record):
-        # type: (LogRecord) -> None
+    def _emit(self, record: LogRecord) -> None:
         if not self._can_record(record):
             return
 
@@ -290,14 +295,12 @@ class BreadcrumbHandler(_BaseHandler):
     Note that you do not have to use this class if the logging integration is enabled, which it is by default.
     """
 
-    def emit(self, record):
-        # type: (LogRecord) -> Any
+    def emit(self, record: LogRecord) -> Any:
         with capture_internal_exceptions():
             self.format(record)
             return self._emit(record)
 
-    def _emit(self, record):
-        # type: (LogRecord) -> None
+    def _emit(self, record: LogRecord) -> None:
         if not self._can_record(record):
             return
 
@@ -305,8 +308,7 @@ class BreadcrumbHandler(_BaseHandler):
             self._breadcrumb_from_record(record), hint={"log_record": record}
         )
 
-    def _breadcrumb_from_record(self, record):
-        # type: (LogRecord) -> Dict[str, Any]
+    def _breadcrumb_from_record(self, record: LogRecord) -> Dict[str, Any]:
         return {
             "type": "log",
             "level": self._logging_to_event_level(record),
@@ -317,21 +319,6 @@ class BreadcrumbHandler(_BaseHandler):
         }
 
 
-def _python_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"),
-        (20, 9, "info"),
-        (10, 5, "debug"),
-        (5, 1, "trace"),
-    ]:
-        if record_level >= py_level:
-            return otel_severity_number, otel_severity_text
-    return 0, "default"
-
-
 class SentryLogsHandler(_BaseHandler):
     """
     A logging handler that records Sentry logs for each Python log record.
@@ -339,8 +326,7 @@ class SentryLogsHandler(_BaseHandler):
     Note that you do not have to use this class if the logging integration is enabled, which it is by default.
     """
 
-    def emit(self, record):
-        # type: (LogRecord) -> Any
+    def emit(self, record: LogRecord) -> Any:
         with capture_internal_exceptions():
             self.format(record)
             if not self._can_record(record):
@@ -353,30 +339,32 @@ class SentryLogsHandler(_BaseHandler):
             if not client.options["_experiments"].get("enable_logs", False):
                 return
 
-            SentryLogsHandler._capture_log_from_record(client, record)
+            self._capture_log_from_record(client, record)
 
-    @staticmethod
-    def _capture_log_from_record(client, record):
-        # type: (BaseClient, LogRecord) -> None
-        scope = sentry_sdk.get_current_scope()
-        otel_severity_number, otel_severity_text = _python_level_to_otel(record.levelno)
+    def _capture_log_from_record(self, client: BaseClient, record: LogRecord) -> None:
+        otel_severity_number, otel_severity_text = _log_level_to_otel(
+            record.levelno, SEVERITY_TO_OTEL_SEVERITY
+        )
         project_root = client.options["project_root"]
-        attrs = {
-            "sentry.origin": "auto.logger.log",
-        }  # type: dict[str, str | bool | float | int]
+        attrs: Any = self._extra_from_record(record)
+        attrs["sentry.origin"] = "auto.logger.log"
         if isinstance(record.msg, str):
             attrs["sentry.message.template"] = record.msg
         if record.args is not None:
             if isinstance(record.args, tuple):
                 for i, arg in enumerate(record.args):
-                    attrs[f"sentry.message.parameters.{i}"] = (
+                    attrs[f"sentry.message.parameter.{i}"] = (
                         arg
-                        if isinstance(arg, str)
-                        or isinstance(arg, float)
-                        or isinstance(arg, int)
-                        or isinstance(arg, bool)
+                        if isinstance(arg, (str, float, int, bool))
                         else safe_repr(arg)
                     )
+            elif isinstance(record.args, dict):
+                for key, value in record.args.items():
+                    attrs[f"sentry.message.parameter.{key}"] = (
+                        value
+                        if isinstance(value, (str, float, int, bool))
+                        else safe_repr(value)
+                    )
         if record.lineno:
             attrs["code.line.number"] = record.lineno
         if record.pathname:
@@ -401,7 +389,6 @@ class SentryLogsHandler(_BaseHandler):
 
         # noinspection PyProtectedMember
         client._capture_experimental_log(
-            scope,
             {
                 "severity_text": otel_severity_text,
                 "severity_number": otel_severity_number,

sentry_sdk/integrations/loguru.py

@@ -1,22 +1,28 @@
+from __future__ import annotations
 import enum
 
+import sentry_sdk
 from sentry_sdk.integrations import Integration, DidNotEnable
 from sentry_sdk.integrations.logging import (
     BreadcrumbHandler,
     EventHandler,
     _BaseHandler,
 )
+from sentry_sdk.logger import _log_level_to_otel
 
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from logging import LogRecord
-    from typing import Optional, Tuple, Any
+    from typing import Any, Optional
 
 try:
     import loguru
     from loguru import logger
     from loguru._defaults import LOGURU_FORMAT as DEFAULT_FORMAT
+
+    if TYPE_CHECKING:
+        from loguru import Message
 except ImportError:
     raise DidNotEnable("LOGURU is not installed")
 
@@ -31,6 +37,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",
@@ -41,61 +51,74 @@ SENTRY_LEVEL_FROM_LOGURU_LEVEL = {
     "CRITICAL": "CRITICAL",
 }
 
-DEFAULT_LEVEL = LoggingLevels.INFO.value
-DEFAULT_EVENT_LEVEL = LoggingLevels.ERROR.value
-# We need to save the handlers to be able to remove them later
-# in tests (they call `LoguruIntegration.__init__` multiple times,
-# and we can't use `setup_once` because it's called before
-# than we get configuration).
-_ADDED_HANDLERS = (None, None)  # type: Tuple[Optional[int], Optional[int]]
+# Map Loguru level numbers to corresponding OTel level numbers
+SEVERITY_TO_OTEL_SEVERITY = {
+    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
+}
 
 
 class LoguruIntegration(Integration):
     identifier = "loguru"
 
+    level: Optional[int] = DEFAULT_LEVEL
+    event_level: Optional[int] = DEFAULT_EVENT_LEVEL
+    breadcrumb_format = DEFAULT_FORMAT
+    event_format = DEFAULT_FORMAT
+    sentry_logs_level: Optional[int] = DEFAULT_LEVEL
+
     def __init__(
         self,
-        level=DEFAULT_LEVEL,
-        event_level=DEFAULT_EVENT_LEVEL,
-        breadcrumb_format=DEFAULT_FORMAT,
-        event_format=DEFAULT_FORMAT,
-    ):
-        # type: (Optional[int], Optional[int], str | loguru.FormatFunction, str | loguru.FormatFunction) -> None
-        global _ADDED_HANDLERS
-        breadcrumb_handler, event_handler = _ADDED_HANDLERS
-
-        if breadcrumb_handler is not None:
-            logger.remove(breadcrumb_handler)
-            breadcrumb_handler = None
-        if event_handler is not None:
-            logger.remove(event_handler)
-            event_handler = None
-
-        if level is not None:
-            breadcrumb_handler = logger.add(
-                LoguruBreadcrumbHandler(level=level),
-                level=level,
-                format=breadcrumb_format,
-            )
+        level: Optional[int] = DEFAULT_LEVEL,
+        event_level: Optional[int] = DEFAULT_EVENT_LEVEL,
+        breadcrumb_format: str | loguru.FormatFunction = DEFAULT_FORMAT,
+        event_format: str | loguru.FormatFunction = DEFAULT_FORMAT,
+        sentry_logs_level: Optional[int] = DEFAULT_LEVEL,
+    ) -> None:
+        LoguruIntegration.level = level
+        LoguruIntegration.event_level = event_level
+        LoguruIntegration.breadcrumb_format = breadcrumb_format
+        LoguruIntegration.event_format = event_format
+        LoguruIntegration.sentry_logs_level = sentry_logs_level
 
-        if event_level is not None:
-            event_handler = logger.add(
-                LoguruEventHandler(level=event_level),
-                level=event_level,
-                format=event_format,
+    @staticmethod
+    def setup_once() -> None:
+        if LoguruIntegration.level is not None:
+            logger.add(
+                LoguruBreadcrumbHandler(level=LoguruIntegration.level),
+                level=LoguruIntegration.level,
+                format=LoguruIntegration.breadcrumb_format,
             )
 
-        _ADDED_HANDLERS = (breadcrumb_handler, event_handler)
+        if LoguruIntegration.event_level is not None:
+            logger.add(
+                LoguruEventHandler(level=LoguruIntegration.event_level),
+                level=LoguruIntegration.event_level,
+                format=LoguruIntegration.event_format,
+            )
 
-    @staticmethod
-    def setup_once():
-        # type: () -> None
-        pass  # we do everything in __init__
+        if LoguruIntegration.sentry_logs_level is not None:
+            logger.add(
+                loguru_sentry_logs_handler,
+                level=LoguruIntegration.sentry_logs_level,
+            )
 
 
 class _LoguruBaseHandler(_BaseHandler):
-    def _logging_to_event_level(self, record):
-        # type: (LogRecord) -> str
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        if kwargs.get("level"):
+            kwargs["level"] = SENTRY_LEVEL_FROM_LOGURU_LEVEL.get(
+                kwargs.get("level", ""), DEFAULT_LEVEL
+            )
+
+        super().__init__(*args, **kwargs)
+
+    def _logging_to_event_level(self, record: LogRecord) -> str:
         try:
             return SENTRY_LEVEL_FROM_LOGURU_LEVEL[
                 LoggingLevels(record.levelno).name
@@ -107,24 +130,71 @@ class _LoguruBaseHandler(_BaseHandler):
 class LoguruEventHandler(_LoguruBaseHandler, EventHandler):
     """Modified version of :class:`sentry_sdk.integrations.logging.EventHandler` to use loguru's level names."""
 
-    def __init__(self, *args, **kwargs):
-        # type: (*Any, **Any) -> None
-        if kwargs.get("level"):
-            kwargs["level"] = SENTRY_LEVEL_FROM_LOGURU_LEVEL.get(
-                kwargs.get("level", ""), DEFAULT_LEVEL
-            )
-
-        super().__init__(*args, **kwargs)
+    pass
 
 
 class LoguruBreadcrumbHandler(_LoguruBaseHandler, BreadcrumbHandler):
     """Modified version of :class:`sentry_sdk.integrations.logging.BreadcrumbHandler` to use loguru's level names."""
 
-    def __init__(self, *args, **kwargs):
-        # type: (*Any, **Any) -> None
-        if kwargs.get("level"):
-            kwargs["level"] = SENTRY_LEVEL_FROM_LOGURU_LEVEL.get(
-                kwargs.get("level", ""), DEFAULT_LEVEL
-            )
+    pass
 
-        super().__init__(*args, **kwargs)
+
+def loguru_sentry_logs_handler(message: Message) -> None:
+    # This is intentionally a callable sink instead of a standard logging handler
+    # since otherwise we wouldn't get direct access to message.record
+    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 (
+        LoguruIntegration.sentry_logs_level is None
+        or record["level"].no < LoguruIntegration.sentry_logs_level
+    ):
+        return
+
+    otel_severity_number, otel_severity_text = _log_level_to_otel(
+        record["level"].no, SEVERITY_TO_OTEL_SEVERITY
+    )
+
+    attrs: dict[str, Any] = {"sentry.origin": "auto.logger.loguru"}
+
+    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[len(project_root) + 1 :]
+        else:
+            attrs["code.file.path"] = record["file"].path
+
+    if record.get("line") is not None:
+        attrs["code.line.number"] = record["line"]
+
+    if record.get("function"):
+        attrs["code.function.name"] = record["function"]
+
+    if record.get("thread"):
+        attrs["thread.name"] = record["thread"].name
+        attrs["thread.id"] = record["thread"].id
+
+    if record.get("process"):
+        attrs["process.pid"] = record["process"].id
+        attrs["process.executable.name"] = record["process"].name
+
+    if record.get("name"):
+        attrs["logger.name"] = record["name"]
+
+    client._capture_experimental_log(
+        {
+            "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,
+        }
+    )