Merge pull request #1 from latchbio/maximsmol/drop-slog

del slog

Author: maximsmol

.envrc

@@ -1,4 +1,3 @@
 #!/usr/bin/env bash
 
-eval "$(conda shell.bash hook)"
-conda activate latch-o11y
+source .venv/bin/activate

.gitignore

@@ -1 +1,2 @@
 dist/
+__pycache__

pyproject.toml

@@ -1,32 +1,31 @@
 [project]
 name = "latch-o11y"
-version = "0.1.5"
+version = "1.0.0"
 description = "Observability for latch python backend services"
 authors = [{ name = "maximsmol", email = "max@latch.bio" }]
 dependencies = [
     "latch-config>=0.1.5",
     "opentelemetry-api>=1.15.0",
     "opentelemetry-sdk>=1.15.0",
     "opentelemetry-exporter-otlp-proto-grpc>=1.15.0",
-    "orjson>=3.8.5",
-    "structlog>=22.3.0",
 ]
 requires-python = "==3.11.*"
 readme = "README.md"
-packages = [{ include = "latch_o11y" }]
 license = { text = "CC0-1.0" }
 
 [build-system]
-requires = ["pdm-backend"]
-build-backend = "pdm.backend"
+requires = ["hatchling"]
+build-backend = "hatchling.build"
 
-[tool.pdm.dev-dependencies]
-dev = [
-    "ruff>=0.4.2",
-    "rich>=13.7.1",
-]
+[tool.uv]
+dev-dependencies = ["ruff>=0.9.5"]
 
 [tool.ruff]
+target-version = "py311"
+
+[tool.ruff.lint]
+preview = true
+
 pydocstyle = { convention = "google" }
 extend-select = [
     "F",
@@ -40,7 +39,7 @@ extend-select = [
     "YTT",
     "ANN",
     "ASYNC",
-    "TRIO",
+    "ASYNC1",
     "S",
     # "BLE", # `raise x from y` does not work
     "FBT",
@@ -104,6 +103,7 @@ ignore = [
     "C901",
 
     "T201",
+    "T203",
 
     "D415",
 
@@ -132,23 +132,36 @@ ignore = [
     "PLW2901",
     "PLW0603",
 
+    "PLR0904",
     "PLR0911",
     "PLR0912",
     "PLR0913",
     "PLR0914",
     "PLR0915",
     "PLR0916",
     "PLR0917",
+    "PLR1702",
     "PLR2004",
 
     "TD001",
     "TD003",
     "TD006",
 
     "TID252",
+
+    "PD901",
+
+    "UP040",
+
+    "SIM112",
+
+    "PLC1901",
+
+    "TCH002",
 ]
 
 [tool.ruff.format]
+preview = true
 skip-magic-trailing-comma = true
 
 [tool.pyright]

latch_o11y/__init__.py renamed to src/latch_o11y/__init__.py

@@ -1,115 +1,85 @@
 import functools
 import inspect
+from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import dataclass
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Awaitable, Callable, Concatenate, ParamSpec, TypeAlias, TypeVar
+from typing import Concatenate, Literal, ParamSpec, TypeAlias, TypeVar
 
-import orjson
-import structlog as slog
 from latch_config.config import DatadogConfig, LoggingMode, read_config
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk.resources import Attributes, LabelValue, Resource
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.sdk.trace import ReadableSpan, TracerProvider
+from opentelemetry.sdk.trace.export import (
+    BatchSpanProcessor,
+    ConsoleSpanExporter,
+    SimpleSpanProcessor,
+    SpanExporter,
+    SpanExportResult,
+)
 from opentelemetry.trace import Tracer
-from opentelemetry.trace.span import INVALID_SPAN, INVALID_SPAN_CONTEXT, Span
-from structlog.types import EventDict, WrappedLogger
+from opentelemetry.trace.span import Span
 
 
-@dataclass(frozen=True)
-class Config:
-    datadog: DatadogConfig
-    logging_mode: LoggingMode = LoggingMode.console_json
+class NoopSpanExporter(SpanExporter):
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        return SpanExportResult.SUCCESS
 
+    def shutdown(self) -> None: ...
 
-config = read_config(Config)
-
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        return True
 
-def add_timestamp(logger: WrappedLogger, name: str, x: EventDict) -> EventDict:
-    # the default slog.processors.TimeStamper is not great with timezones
-    utc = datetime.now(timezone.utc)
-    x["timestamp"] = utc.astimezone().isoformat()
-    return x
 
+def format_console_span(x: ReadableSpan) -> str:
+    ctx = x.context
 
-def add_dd_otel(logger: WrappedLogger, name: str, x: EventDict) -> EventDict:
-    s = trace.get_current_span()
-    if s == INVALID_SPAN:
-        return x
+    parent_ctx = x.parent
+    parent_id = "      root      "
+    if parent_ctx is not None:
+        parent_id = f"{parent_ctx.span_id:x}"
 
-    ctx = s.get_span_context()
-    if ctx == INVALID_SPAN_CONTEXT:
-        return x
+    s_id = "?" * 16
+    if ctx is not None:
+        s_id = f"{ctx.span_id:x}"
+    return f"<{parent_id}> |- <{s_id}> {x.name}\n"
 
-    x["trace_id"] = format(ctx.trace_id, "032x")
-    x["span_id"] = format(ctx.span_id, "016x")
 
-    x["dd.trace_id"] = str(ctx.trace_id & 0xFFFF_FFFF_FFFF_FFFF)
-    x["dd.span_id"] = str(ctx.span_id)
-
-    x["dd.service"] = config.datadog.service_name
-    x["dd.version"] = config.datadog.service_version
-    x["dd.env"] = config.datadog.deployment_environment
+@dataclass(frozen=True)
+class Config:
+    datadog: DatadogConfig
+    logging_mode: LoggingMode = LoggingMode.console_json
 
-    return x
 
+config = read_config(Config)
 
 app_tracer: Tracer
-# fixme(maximsmol): add support for .exception
-log: slog.stdlib.BoundLogger
 
 
-def setup():
-    if config.logging_mode == LoggingMode.file_json:
-        log_file = Path(__file__).parent.parent / "o11y_debug" / "log.json"
-    else:
-        log_file = Path("/dev/stdout")
-
+def setup(*, span_exporter: Literal["otlp", "console", "noop"] = "otlp") -> None:
     service_data: Attributes = {
         "service.name": config.datadog.service_name,
         "service.version": config.datadog.service_version,
         "deployment.environment": config.datadog.deployment_environment,
     }
 
     tracer_provider = TracerProvider(resource=Resource(service_data))
-    tracer_provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
+
+    if span_exporter == "otlp":
+        tracer_provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
+    elif span_exporter == "console":
+        tracer_provider.add_span_processor(
+            SimpleSpanProcessor(ConsoleSpanExporter(formatter=format_console_span))
+        )
+    elif span_exporter == "noop":
+        tracer_provider.add_span_processor(SimpleSpanProcessor(NoopSpanExporter()))
+
     trace.set_tracer_provider(tracer_provider)
 
     global app_tracer
     # todo(maximsmol): setup trace sampling based on datadog settings
     # todo(maximsmol): port over stuff from https://github.com/open-telemetry/opentelemetry-python-contrib/blob/934af7ea4f9b1e0294ced6a014d6eefdda156b2b/exporter/opentelemetry-exporter-datadog/src/opentelemetry/exporter/datadog/exporter.py
     app_tracer = trace.get_tracer(__name__)
 
-    slog.configure_once(
-        processors=[
-            # todo(maximsmol): allow named loggers (needs a custom logging base)
-            # slog.stdlib.add_logger_name,
-            slog.stdlib.add_log_level,
-            add_timestamp,
-            add_dd_otel,
-        ]
-        + (
-            [slog.dev.ConsoleRenderer()]
-            if config.logging_mode == LoggingMode.console
-            else [
-                slog.processors.ExceptionRenderer(
-                    slog.tracebacks.ExceptionDictTransformer()
-                ),
-                slog.processors.JSONRenderer(orjson.dumps),
-            ]
-        ),
-        logger_factory=slog.BytesLoggerFactory(file=log_file.open("wb"))
-        if config.logging_mode != LoggingMode.console
-        else None,
-        wrapper_class=slog.stdlib.AsyncBoundLogger,
-        cache_logger_on_first_use=True,
-    )
-
-    global log
-    log = slog.stdlib.get_logger()
-
 
 T = TypeVar("T")
 P = ParamSpec("P")
@@ -121,7 +91,7 @@ def _trace_function_with_span_async(
     [Callable[Concatenate[Span, P], Awaitable[T]]], Callable[P, Awaitable[T]]
 ]:
     def decorator(
-        f: Callable[Concatenate[Span, P], Awaitable[T]]
+        f: Callable[Concatenate[Span, P], Awaitable[T]],
     ) -> Callable[P, Awaitable[T]]:
         @functools.wraps(f)
         async def inner(*args: P.args, **kwargs: P.kwargs) -> T:
@@ -163,7 +133,7 @@ def inner(*args: P.args, **kwargs: P.kwargs) -> T:
 
 
 def trace_app_function_with_span(
-    f: Callable[Concatenate[Span, P], T]
+    f: Callable[Concatenate[Span, P], T],
 ) -> Callable[P, T]:
     return trace_function_with_span(app_tracer)(f)
 
@@ -201,13 +171,13 @@ def trace_app_function(f: Callable[P, T]) -> Callable[P, T]:
     return trace_function(app_tracer)(f)
 
 
-AttributesDict: TypeAlias = dict[str, LabelValue | "AttributesDict"]
+AttributesDict: TypeAlias = "dict[str, LabelValue | AttributesDict]"
 
 
 def dict_to_attrs(x: AttributesDict, prefix: str) -> Attributes:
     res: Attributes = {}
 
-    def inner(x: LabelValue | AttributesDict, prefix: str):
+    def inner(x: LabelValue | AttributesDict, prefix: str) -> None:
         if isinstance(x, list):
             for i, y in enumerate(x):
                 inner(y, f"{prefix}.{i}")