logfire-api 4.33.0__tar.gz → 4.35.0__tar.gz

{logfire_api-4.33.0 → logfire_api-4.35.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: logfire-api
-Version: 4.33.0
+Version: 4.35.0
 Summary: Shim for the Logfire SDK which does nothing unless Logfire is installed
 Author-email: Pydantic Team <engineering@pydantic.dev>, Samuel Colvin <samuel@pydantic.dev>, Hasan Ramezani <hasan@pydantic.dev>, Adrian Garcia Badaracco <adrian@pydantic.dev>, David Montague <david@pydantic.dev>, Marcelo Trylesinski <marcelo@pydantic.dev>, David Hewitt <david.hewitt@pydantic.dev>, Alex Hall <alex@pydantic.dev>
 License-Expression: MIT
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 
 # logfire-api

{logfire_api-4.33.0 → logfire_api-4.35.0}/logfire_api/__init__.py

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 import importlib
 import sys
-from contextlib import contextmanager, nullcontext
-from typing import Any, ContextManager, Literal, TYPE_CHECKING, Sequence
+from collections.abc import Sequence
+from contextlib import AbstractContextManager, contextmanager, nullcontext
+from typing import TYPE_CHECKING, Any, Literal
 from unittest.mock import MagicMock
 
-
 try:
     logfire_module = importlib.import_module('logfire')
     sys.modules[__name__] = logfire_module
@@ -143,7 +143,7 @@ except ImportError:
             def instrument_wsgi(self, app, *args, **kwargs):
                 return app
 
-            def instrument_fastapi(self, *args, **kwargs) -> ContextManager[None]:
+            def instrument_fastapi(self, *args, **kwargs) -> AbstractContextManager[None]:
                 return nullcontext()
 
             def instrument_pydantic(self, *args, **kwargs) -> None: ...
@@ -176,13 +176,13 @@ except ImportError:
 
             def instrument_asyncpg(self, *args, **kwargs) -> None: ...
 
-            def instrument_anthropic(self, *args, **kwargs) -> ContextManager[None]:
+            def instrument_anthropic(self, *args, **kwargs) -> AbstractContextManager[None]:
                 return nullcontext()
 
-            def instrument_openai(self, *args, **kwargs) -> ContextManager[None]:
+            def instrument_openai(self, *args, **kwargs) -> AbstractContextManager[None]:
                 return nullcontext()
 
-            def instrument_print(self, *args, **kwargs) -> ContextManager[None]:
+            def instrument_print(self, *args, **kwargs) -> AbstractContextManager[None]:
                 return nullcontext()
 
             def instrument_openai_agents(self, *args, **kwargs) -> None: ...
@@ -201,11 +201,17 @@ except ImportError:
 
             def instrument_mcp(self, *args, **kwargs) -> None: ...
 
-            def instrument_claude_agent_sdk(self, *args, **kwargs) -> ContextManager[None]:
+            def instrument_claude_agent_sdk(self, *args, **kwargs) -> AbstractContextManager[None]:
                 return nullcontext()
 
             def url_from_eval(self, *args, **kwargs) -> str | None: ...
 
+            def forward_export_request(self, *args, **kwargs) -> MagicMock:
+                return MagicMock()
+
+            async def forward_export_request_starlette(self, *args, **kwargs) -> MagicMock:
+                return MagicMock()
+
             def shutdown(self, *args, **kwargs) -> None: ...
 
 
@@ -262,6 +268,8 @@ except ImportError:
         shutdown = DEFAULT_LOGFIRE_INSTANCE.shutdown
         suppress_scopes = DEFAULT_LOGFIRE_INSTANCE.suppress_scopes
         url_from_eval = DEFAULT_LOGFIRE_INSTANCE.url_from_eval
+        forward_export_request = DEFAULT_LOGFIRE_INSTANCE.forward_export_request
+        forward_export_request_starlette = DEFAULT_LOGFIRE_INSTANCE.forward_export_request_starlette
 
         def loguru_handler() -> dict[str, Any]:
             return {}
@@ -316,11 +324,11 @@ except ImportError:
         def get_baggage(*args, **kwargs) -> dict[str, str]:
             return {}
 
-        def set_baggage(*args, **kwargs) -> ContextManager[None]:
+        def set_baggage(*args, **kwargs) -> AbstractContextManager[None]:
             return nullcontext()
 
         def get_context(*args, **kwargs) -> dict[str, Any]:
             return {}
 
-        def attach_context(*args, **kwargs) -> ContextManager[None]:
+        def attach_context(*args, **kwargs) -> AbstractContextManager[None]:
             return nullcontext()

{logfire_api-4.33.0 → logfire_api-4.35.0}/logfire_api/__init__.pyi

@@ -16,7 +16,7 @@ from logfire.propagate import attach_context as attach_context, get_context as g
 from logfire.sampling import SamplingOptions as SamplingOptions
 from typing import Any
 
-__all__ = ['Logfire', 'LogfireSpan', 'LevelName', 'AdvancedOptions', 'ConsoleOptions', 'CodeSource', 'PydanticPlugin', 'configure', 'span', 'instrument', 'log', 'trace', 'debug', 'notice', 'info', 'warn', 'warning', 'error', 'exception', 'fatal', 'force_flush', 'log_slow_async_callbacks', 'install_auto_tracing', 'instrument_asgi', 'instrument_wsgi', 'instrument_pydantic', 'instrument_pydantic_ai', 'instrument_fastapi', 'instrument_openai', 'instrument_openai_agents', 'instrument_anthropic', 'instrument_google_genai', 'instrument_litellm', 'instrument_dspy', 'instrument_print', 'instrument_asyncpg', 'instrument_httpx', 'instrument_celery', 'instrument_requests', 'instrument_psycopg', 'instrument_django', 'instrument_flask', 'instrument_starlette', 'instrument_aiohttp_client', 'instrument_aiohttp_server', 'instrument_sqlalchemy', 'instrument_sqlite3', 'instrument_aws_lambda', 'instrument_redis', 'instrument_pymongo', 'instrument_mysql', 'instrument_surrealdb', 'instrument_system_metrics', 'instrument_mcp', 'instrument_claude_agent_sdk', 'AutoTraceModule', 'with_tags', 'with_settings', 'suppress_scopes', 'shutdown', 'no_auto_trace', 'ScrubMatch', 'ScrubbingOptions', 'VERSION', 'add_non_user_code_prefix', 'suppress_instrumentation', 'StructlogProcessor', 'LogfireLoggingHandler', 'loguru_handler', 'SamplingOptions', 'MetricsOptions', 'VariablesOptions', 'LocalVariablesOptions', 'variables', 'var', 'variables_clear', 'variables_get', 'variables_push', 'variables_push_types', 'variables_validate', 'variables_push_config', 'variables_pull_config', 'variables_build_config', 'logfire_info', 'get_baggage', 'set_baggage', 'get_context', 'attach_context', 'url_from_eval']
+__all__ = ['Logfire', 'LogfireSpan', 'LevelName', 'AdvancedOptions', 'ConsoleOptions', 'CodeSource', 'PydanticPlugin', 'configure', 'span', 'instrument', 'log', 'trace', 'debug', 'notice', 'info', 'warn', 'warning', 'error', 'exception', 'fatal', 'force_flush', 'log_slow_async_callbacks', 'install_auto_tracing', 'instrument_asgi', 'instrument_wsgi', 'instrument_pydantic', 'instrument_pydantic_ai', 'instrument_fastapi', 'instrument_openai', 'instrument_openai_agents', 'instrument_anthropic', 'instrument_google_genai', 'instrument_litellm', 'instrument_dspy', 'instrument_print', 'instrument_asyncpg', 'instrument_httpx', 'instrument_celery', 'instrument_requests', 'instrument_psycopg', 'instrument_django', 'instrument_flask', 'instrument_starlette', 'instrument_aiohttp_client', 'instrument_aiohttp_server', 'instrument_sqlalchemy', 'instrument_sqlite3', 'instrument_aws_lambda', 'instrument_redis', 'instrument_pymongo', 'instrument_mysql', 'instrument_surrealdb', 'instrument_system_metrics', 'instrument_mcp', 'instrument_claude_agent_sdk', 'AutoTraceModule', 'with_tags', 'with_settings', 'suppress_scopes', 'shutdown', 'no_auto_trace', 'ScrubMatch', 'ScrubbingOptions', 'VERSION', 'add_non_user_code_prefix', 'suppress_instrumentation', 'StructlogProcessor', 'LogfireLoggingHandler', 'loguru_handler', 'SamplingOptions', 'MetricsOptions', 'VariablesOptions', 'LocalVariablesOptions', 'variables', 'var', 'variables_clear', 'variables_get', 'variables_push', 'variables_push_types', 'variables_validate', 'variables_push_config', 'variables_pull_config', 'variables_build_config', 'logfire_info', 'get_baggage', 'set_baggage', 'get_context', 'attach_context', 'url_from_eval', 'forward_export_request', 'forward_export_request_starlette']
 
 DEFAULT_LOGFIRE_INSTANCE = Logfire()
 span = DEFAULT_LOGFIRE_INSTANCE.span
@@ -61,6 +61,8 @@ shutdown = DEFAULT_LOGFIRE_INSTANCE.shutdown
 with_tags = DEFAULT_LOGFIRE_INSTANCE.with_tags
 with_settings = DEFAULT_LOGFIRE_INSTANCE.with_settings
 url_from_eval = DEFAULT_LOGFIRE_INSTANCE.url_from_eval
+forward_export_request = DEFAULT_LOGFIRE_INSTANCE.forward_export_request
+forward_export_request_starlette = DEFAULT_LOGFIRE_INSTANCE.forward_export_request_starlette
 log = DEFAULT_LOGFIRE_INSTANCE.log
 trace = DEFAULT_LOGFIRE_INSTANCE.trace
 debug = DEFAULT_LOGFIRE_INSTANCE.debug

{logfire_api-4.33.0 → logfire_api-4.35.0}/logfire_api/_internal/config.pyi

@@ -13,6 +13,7 @@ from .exporters.processor_wrapper import CheckSuppressInstrumentationProcessorWr
 from .exporters.quiet_metrics import QuietMetricExporter as QuietMetricExporter
 from .exporters.remove_pending import RemovePendingSpansExporter as RemovePendingSpansExporter
 from .exporters.test import TestExporter as TestExporter
+from .forwarding import OTLPForwardingManager as OTLPForwardingManager
 from .integrations.executors import instrument_executors as instrument_executors
 from .logs import ProxyLoggerProvider as ProxyLoggerProvider
 from .main import Logfire as Logfire
@@ -253,6 +254,8 @@ class LogfireConfig(_LogfireConfigData):
         Returns:
             Whether the flush of spans was successful.
         """
+    def shutdown(self, timeout_millis: int = 30000, flush: bool = True) -> bool:
+        """Shut down variables, forwarding, traces, logs, and metrics."""
     def get_tracer_provider(self) -> ProxyTracerProvider:
         """Get a tracer provider from this `LogfireConfig`.
 
@@ -300,6 +303,7 @@ def emit_configuration_span(config: LogfireConfig, logfire_instance: Logfire, *,
     non-sensitive configuration fields.
     """
 def exit_open_spans() -> None: ...
+def shutdown_otlp_forwarding(timeout_millis: int = 30000) -> None: ...
 
 original_os_exit: Incomplete
 

{logfire_api-4.33.0 → logfire_api-4.35.0}/logfire_api/_internal/config_params.pyi

@@ -11,10 +11,9 @@ from pathlib import Path
 from typing import Any, TypeVar
 
 T = TypeVar('T')
-slots_true: Incomplete
 PydanticPluginRecordValues: Incomplete
 
-@dataclass(**slots_true)
+@dataclass(slots=True)
 class ConfigParam:
     """A parameter that can be configured for a Logfire instance."""
     env_vars: list[str]

logfire_api-4.35.0/logfire_api/_internal/forwarding.pyi

@@ -0,0 +1,85 @@
+from _typeshed import Incomplete
+from collections import deque
+from collections.abc import Callable as Callable, Mapping, Sequence
+from dataclasses import dataclass
+from enum import Enum
+from logfire._internal.exporters.otlp import OTLPExporterHttpSession as OTLPExporterHttpSession
+from logfire._internal.server_response import install_logfire_response_hook as install_logfire_response_hook
+from logfire._internal.utils import suppress_instrumentation as suppress_instrumentation
+from logfire.experimental.forwarding import ForwardExportRequestResponse as ForwardExportRequestResponse
+from logfire.types import ServerResponseCallback as ServerResponseCallback
+from logfire.version import VERSION as VERSION
+from opentelemetry.proto.collector.logs.v1.logs_service_pb2 import ExportLogsServiceResponse
+from opentelemetry.proto.collector.metrics.v1.metrics_service_pb2 import ExportMetricsServiceResponse
+from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import ExportTraceServiceResponse
+from threading import Thread
+from typing import Literal
+
+OTLP_FORWARDING_MAX_QUEUED_BODY_BYTES: Incomplete
+OTLP_FORWARDING_MAX_QUEUED_ITEMS: int
+OTLP_FORWARDING_MAX_REQUEST_BODY_BYTES: Incomplete
+ForwardingPath: Incomplete
+
+@dataclass(frozen=True)
+class ForwardingPathConfig:
+    timeout_env: str
+    default_timeout: float
+    partial_success_rejected_attribute: str
+    response_message_type: type[ExportTraceServiceResponse] | type[ExportLogsServiceResponse] | type[ExportMetricsServiceResponse]
+    def timeout(self) -> float: ...
+
+FORWARDING_CONFIGS: dict[ForwardingPath, ForwardingPathConfig]
+
+class ForwardingContentType(Enum):
+    PROTOBUF: str
+    JSON: str
+
+@dataclass(frozen=True)
+class ForwardingRequest:
+    path: ForwardingPath
+    body: bytes
+    content_type: ForwardingContentType
+    headers: Mapping[str, str]
+    @property
+    def path_config(self) -> ForwardingPathConfig: ...
+
+@dataclass(frozen=True)
+class ForwardingErrorResponse:
+    status_code: int
+    content: bytes
+
+@dataclass(frozen=True)
+class ForwardingAdmissionResult:
+    response: Literal['success', 'partial_success']
+    message: str | None
+
+class OTLPForwardingPipeline:
+    base_url: Incomplete
+    session: Incomplete
+    max_queued_body_bytes: Incomplete
+    max_queued_items: Incomplete
+    queue: deque[ForwardingRequest]
+    worker: Thread | None
+    closed: bool
+    condition: Incomplete
+    tokens: list[str]
+    def __init__(self, *, base_url: str, session: OTLPExporterHttpSession, max_queued_body_bytes: int, max_queued_items: int = ...) -> None: ...
+    @property
+    def queued_body_bytes(self) -> int: ...
+    def enqueue(self, queued_request: ForwardingRequest) -> bool: ...
+    def force_flush(self, timeout_millis: int) -> bool: ...
+    def shutdown(self, timeout_millis: int, *, drain_queued: bool = True) -> bool: ...
+
+class OTLPForwardingManager:
+    pipelines: dict[str, OTLPForwardingPipeline]
+    closed: bool
+    def __init__(self, destinations: Sequence[tuple[str, str]], *, server_response_hook: ServerResponseCallback | None = None) -> None: ...
+    def has_destinations(self) -> bool: ...
+    def submit(self, request: ForwardingRequest) -> ForwardingAdmissionResult: ...
+    def force_flush(self, timeout_millis: int) -> bool: ...
+    def shutdown(self, timeout_millis: int, *, drain_queued: bool = True) -> bool: ...
+
+def parse_forwarding_content_type(content_type: str) -> ForwardingContentType | None: ...
+def build_forwarding_request(*, path: str, headers: Mapping[str, str], body: bytes, max_body_size: int = ...) -> ForwardingRequest | ForwardingErrorResponse: ...
+def build_success_response(request: ForwardingRequest) -> ForwardExportRequestResponse: ...
+def build_partial_success_response(request: ForwardingRequest, *, message: str) -> ForwardExportRequestResponse: ...

{logfire_api-4.33.0 → logfire_api-4.35.0}/logfire_api/_internal/integrations/google_genai.pyi

@@ -2,8 +2,7 @@ import logfire
 from _typeshed import Incomplete
 from logfire._internal.utils import handle_internal_errors as handle_internal_errors, safe_repr as safe_repr
 from opentelemetry._logs import LogRecord, Logger, LoggerProvider
-from typing import Any
-from typing_extensions import TypeAlias
+from typing import Any, TypeAlias
 
 original_flatten_compound_value: Incomplete
 

{logfire_api-4.33.0 → logfire_api-4.35.0}/logfire_api/_internal/integrations/pytest.pyi

@@ -18,22 +18,22 @@ def pytest_configure(config: pytest.Config) -> None:
 def pytest_xdist_setupnodes(config: Any, specs: Any) -> None:
     """Inject TRACEPARENT into env before xdist spawns workers.
 
-    Called in the controller before any ``makegateway()`` call, so all workers
-    inherit the session-level trace context via ``os.environ``.
+    Called in the controller before any `makegateway()` call, so all workers
+    inherit the session-level trace context via `os.environ`.
 
-    NOTE: This relies on ``pytest_sessionstart`` (which creates the session span)
-    running at default priority, *before* xdist's ``DSession.pytest_sessionstart``
-    which uses ``trylast=True`` and calls ``setup_nodes()`` →
-    ``pytest_xdist_setupnodes``.  Do not add ``trylast=True`` to our
-    ``pytest_sessionstart`` or this ordering guarantee breaks.
+    NOTE: This relies on `pytest_sessionstart` (which creates the session span)
+    running at default priority, *before* xdist's `DSession.pytest_sessionstart`
+    which uses `trylast=True` and calls `setup_nodes()` →
+    `pytest_xdist_setupnodes`.  Do not add `trylast=True` to our
+    `pytest_sessionstart` or this ordering guarantee breaks.
     """
 def pytest_sessionstart(session: pytest.Session) -> None:
     """Create a session span when the test session starts.
 
-    IMPORTANT: This hook must run at default priority (no ``trylast=True``).
-    ``pytest_xdist_setupnodes`` depends on the session span being active when
-    it injects TRACEPARENT into ``os.environ`` for worker processes.  xdist's
-    ``DSession.pytest_sessionstart`` uses ``trylast=True``, so our default-priority
+    IMPORTANT: This hook must run at default priority (no `trylast=True`).
+    `pytest_xdist_setupnodes` depends on the session span being active when
+    it injects TRACEPARENT into `os.environ` for worker processes.  xdist's
+    `DSession.pytest_sessionstart` uses `trylast=True`, so our default-priority
     hook is guaranteed to run first.
     """
 def pytest_runtest_protocol(item: pytest.Item, nextitem: pytest.Item | None) -> Generator[None]:
@@ -62,16 +62,16 @@ def logfire_pytest(request: pytest.FixtureRequest) -> Logfire:
 def pytest_pyfunc_call(pyfuncitem: pytest.Function) -> Generator[None]:
     """Re-attach the per-test span context for async test functions.
 
-    The ``pytest_runtest_protocol`` hook creates a span per test and attaches it
-    to the OTel context via ``context_api.attach()`` in the **synchronous** hook
+    The `pytest_runtest_protocol` hook creates a span per test and attaches it
+    to the OTel context via `context_api.attach()` in the **synchronous** hook
     thread.  However, when tests are async (e.g. with anyio/pytest-asyncio), they
-    may run inside an event-loop task whose ``contextvars`` snapshot was taken
-    before the per-test span was attached (e.g. when ``asyncio.Runner`` reuses a
-    saved context on Python 3.11+).  As a result, ``logfire.get_context()`` inside
+    may run inside an event-loop task whose `contextvars` snapshot was taken
+    before the per-test span was attached (e.g. when `asyncio.Runner` reuses a
+    saved context on Python 3.11+).  As a result, `logfire.get_context()` inside
     an async test can return a stale traceparent from a previous test (or no
     context at all).
 
-    This hook wraps async test functions so that ``context_api.attach()`` is called
+    This hook wraps async test functions so that `context_api.attach()` is called
     *inside* the coroutine body, making the span visible to the test and any
-    callbacks (e.g. httpx event hooks) that call ``logfire.get_context()``.
+    callbacks (e.g. httpx event hooks) that call `logfire.get_context()`.
     """

{logfire_api-4.33.0 → logfire_api-4.35.0}/logfire_api/_internal/integrations/system_metrics.pyi

@@ -4,7 +4,7 @@ from logfire import Logfire as Logfire
 from typing import Literal
 from typing_extensions import LiteralString
 
-MetricName: type[Literal['system.cpu.simple_utilization', 'system.cpu.time', 'system.cpu.utilization', 'system.memory.usage', 'system.memory.utilization', 'system.swap.usage', 'system.swap.utilization', 'system.disk.io', 'system.disk.operations', 'system.disk.time', 'system.network.dropped.packets', 'system.network.packets', 'system.network.errors', 'system.network.io', 'system.network.connections', 'system.thread_count', 'process.open_file_descriptor.count', 'process.context_switches', 'process.cpu.time', 'process.cpu.utilization', 'process.cpu.core_utilization', 'process.memory.usage', 'process.memory.virtual', 'process.thread.count', 'process.runtime.gc_count', 'cpython.gc.collected_objects', 'cpython.gc.collections', 'cpython.gc.uncollectable_objects']]
+MetricName: type[Literal['system.cpu.simple_utilization', 'system.cpu.time', 'system.cpu.utilization', 'system.memory.usage', 'system.memory.utilization', 'system.swap.usage', 'system.swap.utilization', 'system.disk.io', 'system.disk.operations', 'system.disk.time', 'system.network.dropped.packets', 'system.network.packets', 'system.network.errors', 'system.network.io', 'system.network.connections', 'system.thread_count', 'process.open_file_descriptor.count', 'process.context_switches', 'process.cpu.time', 'process.cpu.utilization', 'process.cpu.core_utilization', 'process.disk.io', 'process.memory.usage', 'process.memory.virtual', 'process.thread.count', 'process.runtime.gc_count', 'cpython.gc.collected_objects', 'cpython.gc.collections', 'cpython.gc.uncollectable_objects']]
 Config = dict[MetricName, Iterable[str] | None]
 CPU_FIELDS: list[LiteralString]
 MEMORY_FIELDS: list[LiteralString]

{logfire_api-4.33.0 → logfire_api-4.35.0}/logfire_api/_internal/main.pyi

@@ -6,6 +6,7 @@ import pydantic_ai
 import pydantic_ai.models
 import requests
 from . import async_ as async_
+from ..experimental.forwarding import ForwardExportRequestResponse as ForwardExportRequestResponse
 from ..integrations.aiohttp_client import RequestHook as AiohttpClientRequestHook, ResponseHook as AiohttpClientResponseHook
 from ..integrations.flask import CommenterOptions as FlaskCommenterOptions, RequestHook as FlaskRequestHook, ResponseHook as FlaskResponseHook
 from ..integrations.httpx import AsyncRequestHook as HttpxAsyncRequestHook, AsyncResponseHook as HttpxAsyncResponseHook, RequestHook as HttpxRequestHook, ResponseHook as HttpxResponseHook
@@ -51,7 +52,8 @@ from pymongo.monitoring import CommandFailedEvent as CommandFailedEvent, Command
 from sqlalchemy import Engine
 from sqlalchemy.ext.asyncio import AsyncEngine
 from starlette.applications import Starlette
-from starlette.requests import Request as Request
+from starlette.requests import Request
+from starlette.responses import Response
 from starlette.websockets import WebSocket as WebSocket
 from surrealdb.connections.async_template import AsyncTemplate
 from surrealdb.connections.sync_template import SyncTemplate
@@ -398,7 +400,7 @@ class Logfire:
     def install_auto_tracing(self, modules: Sequence[str] | Callable[[AutoTraceModule], bool], *, min_duration: float, check_imported_modules: Literal['error', 'warn', 'ignore'] = 'error') -> None:
         """Install automatic tracing.
 
-        See the [Auto-Tracing guide](https://logfire.pydantic.dev/docs/guides/onboarding_checklist/add_auto_tracing/)
+        See the [Auto-Tracing guide](https://pydantic.dev/docs/logfire/instrument/add-auto-tracing/)
         for more info.
 
         This will trace all non-generator function calls in the modules specified by the modules argument.
@@ -1418,6 +1420,50 @@ class Logfire:
             print(config.model_dump_json(indent=2))
             ```
         '''
+    def forward_export_request(self, *, path: str, headers: Mapping[str, str], body: bytes, max_body_size: int = ...) -> ForwardExportRequestResponse:
+        '''Forward an OpenTelemetry export request to the Logfire backend.
+
+        This method is generic and can be used for any web framework.
+        For Starlette/FastAPI, use `forward_export_request_starlette` instead for extra protection and convenience.
+
+        This is for proxying telemetry from a browser to Logfire so that the write token doesn\'t need to be
+        exposed in the frontend code.
+        See https://pydantic.dev/docs/logfire/typescript-sdk/packages/browser/#python-backend-proxy
+        for more details.
+
+        We recommend protecting the endpoint that uses this method with authentication, rate limiting, and CORS.
+
+        Args:
+            path: one of "/v1/traces", "/v1/metrics", or "/v1/logs"
+            headers: the request headers, as a mapping of header names to values
+            body: the request body, as bytes
+            max_body_size: the maximum allowed body size, in bytes.
+                If the body exceeds this size, the response will be a 413, rejecting the payload.
+
+        Returns:
+            A `ForwardExportRequestResponse` containing the repsonse status code, body, and headers.
+        '''
+    async def forward_export_request_starlette(self, request: Request, *, max_body_size: int = ...) -> Response:
+        """Forward an OpenTelemetry export request to the Logfire backend.
+
+        This method is designed for Starlette/FastAPI.
+        For other web frameworks, use `forward_export_request` instead and adapt the request/response handling as needed.
+
+        This is for proxying telemetry from a browser to Logfire so that the write token doesn't need to be
+        exposed in the frontend code.
+        See https://pydantic.dev/docs/logfire/typescript-sdk/packages/browser/#python-backend-proxy
+        for more details.
+
+        We recommend protecting the endpoint that uses this method with authentication, rate limiting, and CORS.
+
+        Args:
+            request: The Starlette/FastAPI `Request` object.
+            max_body_size: the maximum allowed body size, in bytes.
+                If the body exceeds this size, the response will be a 413, rejecting the payload.
+
+        Returns:
+            A Starlette/FastAPI `Response` object.
+        """
 
 class FastLogfireSpan:
     """A simple version of `LogfireSpan` optimized for auto-tracing."""

{logfire_api-4.33.0 → logfire_api-4.35.0}/logfire_api/_internal/tracer.pyi

@@ -113,4 +113,7 @@ def get_sample_rate_from_attributes(attributes: otel_types.Attributes) -> float
 @handle_internal_errors
 def record_exception(span: trace_api.Span, exception: BaseException, *, attributes: otel_types.Attributes = None, timestamp: int | None = None, escaped: bool = False, callback: ExceptionCallback | None = None) -> None:
     """Similar to the OTEL SDK Span.record_exception method, with our own additions."""
+
+original_format_exception: Incomplete
+
 def set_exception_status(span: trace_api.Span, exception: BaseException): ...

{logfire_api-4.33.0 → logfire_api-4.35.0}/logfire_api/db_api.pyi

@@ -2,7 +2,7 @@ from _typeshed import Incomplete
 from collections.abc import Sequence
 from datetime import datetime, timedelta
 from logfire.experimental.query_client import ColumnDetails as ColumnDetails, LogfireQueryClient as LogfireQueryClient
-from typing import Any
+from typing import Any, overload
 
 apilevel: str
 threadsafety: int
@@ -49,11 +49,15 @@ class Cursor:
     """PEP 249 Cursor that executes queries via `LogfireQueryClient.query_json_rows()`."""
     rowcount: int
     arraysize: int
-    min_timestamp: datetime | None
     max_timestamp: datetime | None
     limit: int
     def __init__(self, connection: Connection) -> None: ...
     @property
+    def min_timestamp(self) -> datetime | None:
+        """Per-cursor override for the lower `start_timestamp` bound."""
+    @min_timestamp.setter
+    def min_timestamp(self, value: datetime | None) -> None: ...
+    @property
     def description(self) -> list[tuple[Any, ...]] | None:
         """Column description as a list of 7-tuples per PEP 249.
 
@@ -88,23 +92,7 @@ class Cursor:
     def __enter__(self) -> Cursor: ...
     def __exit__(self, *args: Any) -> None: ...
 
-def connect(read_token: str, base_url: str | None = None, timeout: float = 30.0, *, min_timestamp: datetime | timedelta | None = ..., max_timestamp: datetime | None = None, limit: int = ..., **kwargs: Any) -> Connection:
-    """Create a PEP 249 connection to the Logfire query API.
-
-    Args:
-        read_token: A Logfire read token for authentication.
-        base_url: Override the default API base URL (inferred from token region).
-        timeout: HTTP request timeout in seconds.
-        min_timestamp: Default lower bound for `start_timestamp` filtering.
-            Accepts a `datetime` for an exact bound, a `timedelta` for a
-            relative window (computed as `now - timedelta`), or `None` to
-            disable the filter.  Defaults to 1 day ago.
-        max_timestamp: Default upper bound for `start_timestamp` filtering.
-        limit: Default row limit per query (max 10,000). When the number of
-            returned rows equals the limit a warning is emitted.
-        **kwargs: Additional keyword arguments forwarded to the underlying
-            `httpx.Client`.
-
-    Returns:
-        A PEP 249 `Connection` object.
-    """
+@overload
+def connect(read_token: str, base_url: str | None = None, timeout: float = 30.0, *, min_timestamp: None, max_timestamp: datetime | None = None, limit: int = ..., **kwargs: Any) -> Connection: ...
+@overload
+def connect(read_token: str, base_url: str | None = None, timeout: float = 30.0, *, min_timestamp: datetime | timedelta = ..., max_timestamp: datetime | None = None, limit: int = ..., **kwargs: Any) -> Connection: ...

logfire_api-4.35.0/logfire_api/experimental/forwarding.pyi

@@ -0,0 +1,25 @@
+import logfire
+from collections.abc import Mapping
+from dataclasses import dataclass
+from starlette.requests import Request
+from starlette.responses import Response
+
+__all__ = ['ForwardExportRequestResponse', 'forward_export_request', 'logfire_proxy']
+
+@dataclass
+class ForwardExportRequestResponse:
+    """Response returned from a forwarded export request to Logfire."""
+    status_code: int
+    headers: Mapping[str, str]
+    content: bytes
+
+def forward_export_request(*, path: str, headers: Mapping[str, str], body: bytes, logfire_instance: logfire.Logfire | None = None, max_body_size: int = ...) -> ForwardExportRequestResponse:
+    """Forward an export request to the Logfire API.
+
+    See the Logfire.forward_export_request method for more details.
+    """
+async def logfire_proxy(request: Request, *, logfire_instance: logfire.Logfire | None = None, max_body_size: int = ...) -> Response:
+    """A Starlette/FastAPI handler to proxy requests to Logfire.
+
+    See the Logfire.forward_export_request_starlette method for more details.
+    """

logfire_api-4.35.0/logfire_api/experimental/query_client.pyi

@@ -0,0 +1,123 @@
+from _typeshed import Incomplete
+from datetime import datetime
+from httpx import AsyncClient, Client, Response, Timeout
+from httpx._client import BaseClient
+from logfire import VERSION as VERSION
+from logfire._internal.config import get_base_url_from_token as get_base_url_from_token
+from logfire._internal.stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
+from pyarrow import Table
+from types import TracebackType
+from typing import Any, Generic, TypeVar, TypedDict, overload
+from typing_extensions import Self
+
+DEFAULT_TIMEOUT: Incomplete
+
+class QueryExecutionError(RuntimeError):
+    """Raised when the query execution fails on the server."""
+class QueryRequestError(RuntimeError):
+    """Raised when the query request is invalid."""
+class InfoRequestError(RuntimeError):
+    """Raised when the request for read token info fails because of unavailable information."""
+
+class ReadTokenInfo(TypedDict, total=False):
+    """Information about the read token."""
+    organization_name: str
+    project_name: str
+
+class ColumnDetails(TypedDict):
+    """The details of a column in the row-oriented JSON-format query results."""
+    name: str
+    datatype: Any
+    nullable: bool
+
+class ColumnData(ColumnDetails):
+    """The data of a column in the column-oriented JSON-format query results."""
+    values: list[Any]
+
+class QueryResults(TypedDict):
+    """The (column-oriented) results of a JSON-format query."""
+    columns: list[ColumnData]
+
+class RowQueryResults(TypedDict):
+    """The row-oriented results of a JSON-format query."""
+    columns: list[ColumnDetails]
+    rows: list[dict[str, Any]]
+T = TypeVar('T', bound=BaseClient)
+
+class _BaseLogfireQueryClient(Generic[T]):
+    base_url: Incomplete
+    read_token: Incomplete
+    timeout: Incomplete
+    client: T
+    def __init__(self, base_url: str, read_token: str, timeout: Timeout, client: type[T], **client_kwargs: Any) -> None: ...
+    def handle_response_errors(self, response: Response) -> None: ...
+
+class LogfireQueryClient(_BaseLogfireQueryClient[Client]):
+    """A synchronous client for querying Logfire data."""
+    def __init__(self, read_token: str, base_url: str | None = None, timeout: Timeout = ..., **client_kwargs: Any) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, exc_type: type[BaseException] | None = None, exc_value: BaseException | None = None, traceback: TracebackType | None = None) -> None: ...
+    def info(self) -> ReadTokenInfo:
+        """Get information about the read token."""
+    def query_json(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None) -> QueryResults:
+        """Query Logfire data and return the results as a column-oriented dictionary."""
+    @overload
+    def query_json_rows(self, sql: str, min_timestamp: None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> RowQueryResults: ...
+    @overload
+    def query_json_rows(self, sql: str, min_timestamp: datetime, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> RowQueryResults: ...
+    @overload
+    def query_arrow(self, sql: str, min_timestamp: None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> Table: ...
+    @overload
+    def query_arrow(self, sql: str, min_timestamp: datetime, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> Table: ...
+    @overload
+    def query_csv(self, sql: str, min_timestamp: None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> str: ...
+    @overload
+    def query_csv(self, sql: str, min_timestamp: datetime, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> str: ...
+
+class AsyncLogfireQueryClient(_BaseLogfireQueryClient[AsyncClient]):
+    """An asynchronous client for querying Logfire data."""
+    def __init__(self, read_token: str, base_url: str | None = None, timeout: Timeout = ..., **async_client_kwargs: Any) -> None: ...
+    async def __aenter__(self) -> Self: ...
+    async def __aexit__(self, exc_type: type[BaseException] | None = None, exc_value: BaseException | None = None, traceback: TracebackType | None = None) -> None: ...
+    async def info(self) -> ReadTokenInfo:
+        """Get information about the read token."""
+    @overload
+    async def query_json_rows(self, sql: str, min_timestamp: None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> RowQueryResults: ...
+    @overload
+    async def query_json_rows(self, sql: str, min_timestamp: datetime, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> RowQueryResults: ...
+    async def query_json(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None) -> QueryResults:
+        """Query Logfire data and return the results as a column-oriented dictionary."""
+    async def query_json_rows(self, sql: str, min_timestamp: datetime | None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> RowQueryResults:
+        """Query Logfire data and return the results as a row-oriented dictionary.
+
+        Args:
+            sql: The SQL `SELECT` query to execute.
+            min_timestamp: The minimum timestamp to use when querying data. If the provided
+                [`datetime`][datetime.datetime] doesn't have a timezone set, it is assumed to
+                be UTC.
+
+                /// version-deprecated | v4.35.0
+                Not providing a `min_timestamp` is deprecated.
+                ///
+            max_timestamp: The maximum timestamp to use when querying data. If the provided
+                [`datetime`][datetime.datetime] doesn't have a timezone set, it is assumed to
+                be UTC.
+            limit: The maximum number of rows to query. This value takes priority over the
+                `LIMIT` clause in the `sql` query.
+            timezone: The timezone to use for the query execution context.
+            environment: Restrict rows to the provided environment(s). To only query rows where no environment is set,
+                use the empty string (`''`).
+
+        Returns:
+            A dictionary with two entries:
+              * `columns`: A list of column details including the name, datatype and whether the column is nullable.
+              * `rows`: The list of rows matching the query.
+        """
+    @overload
+    async def query_arrow(self, sql: str, min_timestamp: None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> Table: ...
+    @overload
+    async def query_arrow(self, sql: str, min_timestamp: datetime, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> Table: ...
+    @overload
+    async def query_csv(self, sql: str, min_timestamp: None = None, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> str: ...
+    @overload
+    async def query_csv(self, sql: str, min_timestamp: datetime, max_timestamp: datetime | None = None, limit: int | None = None, *, timezone: str | None = None, environment: str | list[str] | None = None) -> str: ...

logfire_api-4.35.0/logfire_api/query_client.pyi

@@ -0,0 +1,3 @@
+from .experimental.query_client import AsyncLogfireQueryClient as AsyncLogfireQueryClient, ColumnData as ColumnData, ColumnDetails as ColumnDetails, InfoRequestError as InfoRequestError, LogfireQueryClient as LogfireQueryClient, QueryExecutionError as QueryExecutionError, QueryRequestError as QueryRequestError, QueryResults as QueryResults, ReadTokenInfo as ReadTokenInfo, RowQueryResults as RowQueryResults
+
+__all__ = ['QueryExecutionError', 'QueryRequestError', 'InfoRequestError', 'ReadTokenInfo', 'ColumnDetails', 'ColumnData', 'QueryResults', 'RowQueryResults', 'LogfireQueryClient', 'AsyncLogfireQueryClient']

{logfire_api-4.33.0 → logfire_api-4.35.0}/logfire_api/variables/__init__.pyi

@@ -1,5 +1,5 @@
-from logfire.variables.abstract import ResolvedVariable as ResolvedVariable, SyncMode as SyncMode, ValidationReport as ValidationReport, VariableAlreadyExistsError as VariableAlreadyExistsError, VariableNotFoundError as VariableNotFoundError, VariableWriteError as VariableWriteError
+from logfire.variables.abstract import ResolutionReason as ResolutionReason, ResolvedVariable as ResolvedVariable, SyncMode as SyncMode, ValidationReport as ValidationReport, VariableAlreadyExistsError as VariableAlreadyExistsError, VariableNotFoundError as VariableNotFoundError, VariableWriteError as VariableWriteError
 from logfire.variables.config import KeyIsNotPresent as KeyIsNotPresent, KeyIsPresent as KeyIsPresent, LabelRef as LabelRef, LabeledValue as LabeledValue, LatestVersion as LatestVersion, LocalVariablesOptions as LocalVariablesOptions, Rollout as Rollout, RolloutOverride as RolloutOverride, ValueDoesNotEqual as ValueDoesNotEqual, ValueDoesNotMatchRegex as ValueDoesNotMatchRegex, ValueEquals as ValueEquals, ValueIsIn as ValueIsIn, ValueIsNotIn as ValueIsNotIn, ValueMatchesRegex as ValueMatchesRegex, VariableConfig as VariableConfig, VariableTypeConfig as VariableTypeConfig, VariablesConfig as VariablesConfig
 from logfire.variables.variable import ResolveFunction as ResolveFunction, Variable as Variable, targeting_context as targeting_context
 
-__all__ = ['Variable', 'ResolvedVariable', 'ResolveFunction', 'VariablesConfig', 'VariableConfig', 'VariableTypeConfig', 'LocalVariablesOptions', 'LabeledValue', 'LabelRef', 'LatestVersion', 'Rollout', 'RolloutOverride', 'KeyIsPresent', 'KeyIsNotPresent', 'ValueEquals', 'ValueDoesNotEqual', 'ValueIsIn', 'ValueIsNotIn', 'ValueMatchesRegex', 'ValueDoesNotMatchRegex', 'targeting_context', 'SyncMode', 'ValidationReport', 'VariableAlreadyExistsError', 'VariableNotFoundError', 'VariableWriteError']
+__all__ = ['Variable', 'ResolvedVariable', 'ResolveFunction', 'VariablesConfig', 'VariableConfig', 'VariableTypeConfig', 'LocalVariablesOptions', 'LabeledValue', 'LabelRef', 'LatestVersion', 'Rollout', 'RolloutOverride', 'KeyIsPresent', 'KeyIsNotPresent', 'ValueEquals', 'ValueDoesNotEqual', 'ValueIsIn', 'ValueIsNotIn', 'ValueMatchesRegex', 'ValueDoesNotMatchRegex', 'targeting_context', 'ResolutionReason', 'SyncMode', 'ValidationReport', 'VariableAlreadyExistsError', 'VariableNotFoundError', 'VariableWriteError']