logfire-api 4.32.1__tar.gz → 4.34.0__tar.gz

{logfire_api-4.32.1 → logfire_api-4.34.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: logfire-api
-Version: 4.32.1
+Version: 4.34.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.32.1 → logfire_api-4.34.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.32.1 → logfire_api-4.34.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.32.1 → logfire_api-4.34.0}/logfire_api/_internal/auto_trace/__init__.pyi

@@ -2,8 +2,8 @@ from ..constants import ONE_SECOND_IN_NANOSECONDS as ONE_SECOND_IN_NANOSECONDS
 from ..main import Logfire as Logfire
 from .import_hook import LogfireFinder as LogfireFinder
 from .types import AutoTraceModule as AutoTraceModule
-from collections.abc import Sequence
-from typing import Callable, Literal
+from collections.abc import Callable, Sequence
+from typing import Literal
 
 def install_auto_tracing(logfire: Logfire, modules: Sequence[str] | Callable[[AutoTraceModule], bool], *, min_duration: float, check_imported_modules: Literal['error', 'warn', 'ignore'] = 'error') -> None:
     """Install automatic tracing.

{logfire_api-4.32.1 → logfire_api-4.34.0}/logfire_api/_internal/auto_trace/import_hook.pyi

@@ -2,12 +2,12 @@ from ..main import Logfire as Logfire
 from ..utils import log_internal_error as log_internal_error
 from .rewrite_ast import compile_source as compile_source
 from .types import AutoTraceModule as AutoTraceModule
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 from importlib.abc import Loader, MetaPathFinder
 from importlib.machinery import ModuleSpec
 from types import ModuleType
-from typing import Any, Callable
+from typing import Any
 
 @dataclass
 class LogfireFinder(MetaPathFinder):

{logfire_api-4.32.1 → logfire_api-4.34.0}/logfire_api/_internal/auto_trace/rewrite_ast.pyi

@@ -1,9 +1,10 @@
 import ast
 from ..ast_utils import BaseTransformer as BaseTransformer, LogfireArgs as LogfireArgs
 from ..main import Logfire as Logfire
+from collections.abc import Callable
 from contextlib import AbstractContextManager as AbstractContextManager
 from dataclasses import dataclass
-from typing import Any, Callable, TypeVar
+from typing import Any, TypeVar
 
 def compile_source(tree: ast.AST, filename: str, module_name: str, logfire_instance: Logfire, min_duration: int) -> Callable[[dict[str, Any]], None]:
     """Compile a modified AST of the module's source code in the module's namespace.

{logfire_api-4.32.1 → logfire_api-4.34.0}/logfire_api/_internal/baggage.pyi

@@ -1,5 +1,5 @@
 from _typeshed import Incomplete
-from collections.abc import Iterator
+from collections.abc import Generator
 from contextlib import contextmanager
 from opentelemetry import context
 from opentelemetry.sdk.trace import Span, SpanProcessor
@@ -9,7 +9,7 @@ __all__ = ['get_baggage', 'set_baggage']
 get_baggage: Incomplete
 
 @contextmanager
-def set_baggage(**values: str) -> Iterator[None]:
+def set_baggage(**values: str) -> Generator[None]:
     '''Context manager that attaches key/value pairs as OpenTelemetry baggage to the current context.
 
     See the [Baggage documentation](https://logfire.pydantic.dev/docs/reference/advanced/baggage/) for more details.

logfire_api-4.34.0/logfire_api/_internal/cli/ai_tools.pyi

@@ -0,0 +1,32 @@
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from logfire._internal.utils import read_toml_file as read_toml_file
+from logfire.exceptions import LogfireConfigError as LogfireConfigError
+from pathlib import Path
+from rich.console import Console
+from typing import Any
+
+LOCAL_TOKEN_PLACEHOLDER: str
+LOGFIRE_MCP_TOML: str
+
+@dataclass(frozen=True)
+class AiToolIntegration:
+    name: str
+    display_name: str
+    binary: str
+    env: dict[str, str]
+    model_env: dict[str, str] = field(default_factory=dict[str, str])
+    setup: Callable[[str, str | None, Path, str], dict[str, str]] | None = ...
+    configure_mcp: Callable[[str, Console, bool], None] | None = ...
+    description: str = ...
+    notice: str = ...
+    def binary_path(self) -> str | None: ...
+    def build_gateway_env(self, *, proxy_base: str, model: str | None, workdir: Path, local_token: str) -> dict[str, str]: ...
+    def configure_mcp_server(self, *, mcp_url: str, console: Console, update: bool) -> None: ...
+
+def gateway_template_values(proxy_base: str, local_token: str) -> dict[str, str]: ...
+def resolve_ai_tool(name: str) -> AiToolIntegration: ...
+def ai_tool_names() -> tuple[str, ...]: ...
+def opencode_mcp_json(url: str) -> dict[str, Any]: ...
+
+AI_TOOL_INTEGRATIONS: dict[str, AiToolIntegration]

logfire_api-4.34.0/logfire_api/_internal/cli/gateway.pyi

@@ -0,0 +1,48 @@
+import argparse
+import httpx
+from .ai_tools import AiToolIntegration as AiToolIntegration, LOCAL_TOKEN_PLACEHOLDER as LOCAL_TOKEN_PLACEHOLDER, ai_tool_names as ai_tool_names, gateway_template_values as gateway_template_values, resolve_ai_tool as resolve_ai_tool
+from .gateway_auth import CimdOAuthClient as CimdOAuthClient, GATEWAY_CIMD_PATH as GATEWAY_CIMD_PATH, GatewayAuth as GatewayAuth, GatewayError as GatewayError, OAuthSession as OAuthSession, discover_oauth_metadata as discover_oauth_metadata
+from _typeshed import Incomplete
+from dataclasses import dataclass
+from logfire.exceptions import LogfireConfigError as LogfireConfigError
+from typing import Any, Literal
+
+DEFAULT_PORT: int
+DEFAULT_SCOPE: str
+OAUTH_CALLBACK_PATH: str
+console: Incomplete
+
+@dataclass(frozen=True)
+class GatewayRegion:
+    backend: str
+    gateway: str
+    client_id: str
+
+GATEWAY_REGIONS: dict[str, GatewayRegion]
+
+@dataclass(frozen=True)
+class GatewayCommandContext:
+    raw_args: list[str]
+    region: str | None
+    logfire_url: str | None
+
+@dataclass(frozen=True)
+class GatewayCommand:
+    name: Literal['usage', 'launch', 'serve']
+    args: tuple[str, ...]
+
+def filter_headers(headers: dict[str, str], *, direction: str) -> list[tuple[str, str]]: ...
+
+@dataclass
+class ProxyState:
+    auth: GatewayAuth
+    client: httpx.AsyncClient
+    gateway: str
+    region: str
+    local_token: str
+
+def build_app(state: ProxyState) -> Any: ...
+def parse_gateway_command(context: GatewayCommandContext) -> GatewayCommand: ...
+def execute_gateway_command(command: GatewayCommand, context: GatewayCommandContext) -> int: ...
+def parse_gateway(args: argparse.Namespace) -> None:
+    """Run a local OAuth proxy for the Logfire AI Gateway."""

logfire_api-4.34.0/logfire_api/_internal/cli/gateway_auth.pyi

@@ -0,0 +1,61 @@
+import asyncio
+from _typeshed import Incomplete
+from dataclasses import dataclass, field
+from typing import Any
+
+REFRESH_MARGIN_SECONDS: float
+console: Incomplete
+
+class GatewayError(Exception):
+    """Expected gateway failure rendered to the user without a traceback."""
+
+@dataclass(frozen=True)
+class OAuthMetadata:
+    authorization_endpoint: str
+    token_endpoint: str
+    device_authorization_endpoint: str
+
+async def discover_oauth_metadata(http: Any, backend: str) -> OAuthMetadata:
+    """Fetch the backend's OAuth authorization server metadata."""
+
+GATEWAY_CIMD_PATH: str
+
+class CimdOAuthClient:
+    """Public OAuth client identified by a CIMD URL."""
+    client_id: Incomplete
+    def __init__(self, http: Any, metadata: OAuthMetadata, *, client_id: str) -> None: ...
+    async def start_device_authorization(self, data: dict[str, str]) -> Any: ...
+    async def post_token(self, data: dict[str, str]) -> Any: ...
+
+@dataclass
+class AuthBootstrap:
+    redirect_uri: str
+    expected_state: str = ...
+    code_verifier: str = ...
+    received_code: str | None = ...
+    error: str | None = ...
+    event: asyncio.Event = field(default_factory=asyncio.Event)
+
+@dataclass(frozen=True)
+class OAuthCallbackResult:
+    title: str
+    body: str
+    status_code: int = ...
+
+class OAuthSession:
+    """In-memory OAuth token state for the local gateway proxy."""
+    def __init__(self, client: CimdOAuthClient, metadata: OAuthMetadata, *, resource: str, scope: str) -> None: ...
+    async def auth_code_flow(self, bootstrap: AuthBootstrap) -> None: ...
+    async def device_flow(self) -> None: ...
+    async def refresh(self) -> None: ...
+    async def current_access_token(self) -> str: ...
+    async def force_refresh(self) -> str: ...
+
+class GatewayAuth:
+    """OAuth control-plane for an authorized local gateway proxy session."""
+    def __init__(self, session: OAuthSession, *, redirect_uri: str, flow: str) -> None: ...
+    async def authorize(self) -> None: ...
+    async def current_access_token(self) -> str: ...
+    async def recover_after_rejection(self, *, use_reauth: bool) -> bool: ...
+    async def reauthorize(self) -> None: ...
+    def complete_browser_callback(self, *, error: str | None, error_description: str | None, code: str | None, state: str | None) -> OAuthCallbackResult: ...

logfire_api-4.34.0/logfire_api/_internal/cli/prompt.pyi

@@ -0,0 +1,14 @@
+import argparse
+from _typeshed import Incomplete
+from logfire._internal.cli.ai_tools import resolve_ai_tool as resolve_ai_tool
+from logfire._internal.cli.auth import parse_auth as parse_auth
+from logfire._internal.client import LogfireClient as LogfireClient
+from logfire.exceptions import LogfireConfigError as LogfireConfigError
+
+PROMPT_AI_TOOLS: Incomplete
+
+def parse_prompt(args: argparse.Namespace) -> None:
+    """Creates a prompt to be used with your favorite LLM.
+
+    The prompt assumes you are using Logfire MCP.
+    """

{logfire_api-4.32.1 → logfire_api-4.34.0}/logfire_api/_internal/client.pyi

@@ -1,4 +1,5 @@
 from .auth import UserToken as UserToken, UserTokenCollection as UserTokenCollection
+from .server_response import ServerResponseCallback as ServerResponseCallback, install_logfire_response_hook as install_logfire_response_hook
 from .utils import UnexpectedResponse as UnexpectedResponse
 from _typeshed import Incomplete
 from logfire.exceptions import LogfireConfigError as LogfireConfigError
@@ -19,11 +20,13 @@ class LogfireClient:
 
     Args:
         user_token: The user token to use when authenticating against the API.
+        server_response_hook: Optional override for the API response hook (see
+            `AdvancedOptions.server_response_hook`).
     """
     base_url: Incomplete
-    def __init__(self, user_token: UserToken) -> None: ...
+    def __init__(self, user_token: UserToken, server_response_hook: ServerResponseCallback | None = None) -> None: ...
     @classmethod
-    def from_url(cls, base_url: str | None) -> Self:
+    def from_url(cls, base_url: str | None, server_response_hook: ServerResponseCallback | None = None) -> Self:
         """Create a client from the provided base URL.
 
         Args:
@@ -31,6 +34,8 @@ class LogfireClient:
                 the user into selecting a token from the token collection (or, if only one available,
                 use it directly). The token collection will be created from the `~/.logfire/default.toml`
                 file (or an empty one if no such file exists).
+            server_response_hook: Optional override for the API response hook (see
+                `AdvancedOptions.server_response_hook`).
         """
     def get_user_organizations(self) -> list[dict[str, Any]]:
         """Get the organizations of the logged-in user."""

{logfire_api-4.32.1 → logfire_api-4.34.0}/logfire_api/_internal/config.pyi

@@ -1,33 +1,35 @@
-import atexit
 import dataclasses
 import requests
 from ..propagate import NoExtractTraceContextPropagator as NoExtractTraceContextPropagator, WarnOnExtractTraceContextPropagator as WarnOnExtractTraceContextPropagator
 from ..types import ExceptionCallback as ExceptionCallback
 from .client import InvalidProjectName as InvalidProjectName, LogfireClient as LogfireClient, ProjectAlreadyExists as ProjectAlreadyExists
 from .config_params import ParamManager as ParamManager, PydanticPluginRecordValues as PydanticPluginRecordValues, normalize_token as normalize_token
-from .constants import LEVEL_NUMBERS as LEVEL_NUMBERS, LevelName as LevelName, RESOURCE_ATTRIBUTES_CODE_ROOT_PATH as RESOURCE_ATTRIBUTES_CODE_ROOT_PATH, RESOURCE_ATTRIBUTES_CODE_WORK_DIR as RESOURCE_ATTRIBUTES_CODE_WORK_DIR, RESOURCE_ATTRIBUTES_DEPLOYMENT_ENVIRONMENT_NAME as RESOURCE_ATTRIBUTES_DEPLOYMENT_ENVIRONMENT_NAME, RESOURCE_ATTRIBUTES_VCS_REPOSITORY_REF_REVISION as RESOURCE_ATTRIBUTES_VCS_REPOSITORY_REF_REVISION, RESOURCE_ATTRIBUTES_VCS_REPOSITORY_URL as RESOURCE_ATTRIBUTES_VCS_REPOSITORY_URL
+from .constants import ATTRIBUTES_CONFIG as ATTRIBUTES_CONFIG, ATTRIBUTES_PACKAGE_VERSIONS as ATTRIBUTES_PACKAGE_VERSIONS, LEVEL_NUMBERS as LEVEL_NUMBERS, LevelName as LevelName, RESOURCE_ATTRIBUTES_CODE_ROOT_PATH as RESOURCE_ATTRIBUTES_CODE_ROOT_PATH, RESOURCE_ATTRIBUTES_CODE_WORK_DIR as RESOURCE_ATTRIBUTES_CODE_WORK_DIR, RESOURCE_ATTRIBUTES_DEPLOYMENT_ENVIRONMENT_NAME as RESOURCE_ATTRIBUTES_DEPLOYMENT_ENVIRONMENT_NAME, RESOURCE_ATTRIBUTES_VCS_REPOSITORY_REF_REVISION as RESOURCE_ATTRIBUTES_VCS_REPOSITORY_REF_REVISION, RESOURCE_ATTRIBUTES_VCS_REPOSITORY_URL as RESOURCE_ATTRIBUTES_VCS_REPOSITORY_URL, RESOURCE_ATTRIBUTES_VERSION as RESOURCE_ATTRIBUTES_VERSION
 from .exporters.console import ConsoleColorsValues as ConsoleColorsValues, ConsoleLogExporter as ConsoleLogExporter, IndentedConsoleSpanExporter as IndentedConsoleSpanExporter, ShowParentsConsoleSpanExporter as ShowParentsConsoleSpanExporter, SimpleConsoleSpanExporter as SimpleConsoleSpanExporter
 from .exporters.dynamic_batch import DynamicBatchSpanProcessor as DynamicBatchSpanProcessor
 from .exporters.logs import CheckSuppressInstrumentationLogProcessorWrapper as CheckSuppressInstrumentationLogProcessorWrapper, MainLogProcessorWrapper as MainLogProcessorWrapper
-from .exporters.otlp import BodySizeCheckingOTLPSpanExporter as BodySizeCheckingOTLPSpanExporter, OTLPExporterHttpSession as OTLPExporterHttpSession, QuietLogExporter as QuietLogExporter, QuietSpanExporter as QuietSpanExporter, RetryFewerSpansSpanExporter as RetryFewerSpansSpanExporter
+from .exporters.otlp import BodySizeCheckingOTLPSpanExporter as BodySizeCheckingOTLPSpanExporter, OTLPExporterHttpSession as OTLPExporterHttpSession, QuietLogExporter as QuietLogExporter, QuietSpanExporter as QuietSpanExporter, RetryFewerSpansSpanExporter as RetryFewerSpansSpanExporter, cleanup_disk_retryers as cleanup_disk_retryers
 from .exporters.processor_wrapper import CheckSuppressInstrumentationProcessorWrapper as CheckSuppressInstrumentationProcessorWrapper, MainSpanProcessorWrapper as MainSpanProcessorWrapper
 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
 from .metrics import ProxyMeterProvider as ProxyMeterProvider
 from .scrubbing import BaseScrubber as BaseScrubber, NOOP_SCRUBBER as NOOP_SCRUBBER, Scrubber as Scrubber, ScrubbingOptions as ScrubbingOptions
+from .server_response import ServerResponseCallback as ServerResponseCallback, install_logfire_response_hook as install_logfire_response_hook
 from .stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
 from .tracer import OPEN_SPANS as OPEN_SPANS, PendingSpanProcessor as PendingSpanProcessor, ProxyTracerProvider as ProxyTracerProvider
 from .utils import SeededRandomIdGenerator as SeededRandomIdGenerator, ensure_data_dir_exists as ensure_data_dir_exists, handle_internal_errors as handle_internal_errors, platform_is_emscripten as platform_is_emscripten, suppress_instrumentation as suppress_instrumentation
 from _typeshed import Incomplete
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 from datetime import timedelta
 from logfire._internal.auth import PYDANTIC_LOGFIRE_TOKEN_PATTERN as PYDANTIC_LOGFIRE_TOKEN_PATTERN, REGIONS as REGIONS
 from logfire._internal.baggage import DirectBaggageAttributesSpanProcessor as DirectBaggageAttributesSpanProcessor
+from logfire._internal.collect_system_info import collect_package_info as collect_package_info
 from logfire.exceptions import LogfireConfigError as LogfireConfigError
 from logfire.sampling import SamplingOptions as SamplingOptions
 from logfire.sampling._tail_sampling import TailSamplingProcessor as TailSamplingProcessor
@@ -40,7 +42,7 @@ from opentelemetry.sdk.metrics.view import View
 from opentelemetry.sdk.trace import SpanProcessor
 from opentelemetry.sdk.trace.id_generator import IdGenerator
 from pathlib import Path
-from typing import Any, Callable, ClassVar, Literal, TextIO, TypedDict
+from typing import Any, ClassVar, Literal, TextIO, TypedDict
 from typing_extensions import Self, Unpack
 
 CREDENTIALS_FILENAME: str
@@ -68,6 +70,8 @@ class AdvancedOptions:
     ns_timestamp_generator: Callable[[], int] = ...
     log_record_processors: Sequence[LogRecordProcessor] = ...
     exception_callback: ExceptionCallback | None = ...
+    emit_configuration_span: bool | None = ...
+    server_response_hook: ServerResponseCallback | None = ...
     def generate_base_url(self, token: str) -> str: ...
 
 @dataclass
@@ -250,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`.
 
@@ -289,8 +295,15 @@ class LogfireConfig(_LogfireConfigData):
     def warn_if_not_initialized(self, message: str): ...
     def suppress_scopes(self, *scopes: str) -> None: ...
 
-@atexit.register
+@handle_internal_errors
+def emit_configuration_span(config: LogfireConfig, logfire_instance: Logfire, *, local: bool) -> None:
+    """Emit a span describing the active Logfire configuration and installed packages.
+
+    Only runs when `advanced.emit_configuration_span` is `True`. Sends a curated set of
+    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.32.1 → logfire_api-4.34.0}/logfire_api/_internal/config_params.pyi

@@ -3,18 +3,17 @@ from .constants import LevelName as LevelName
 from .exporters.console import ConsoleColorsValues as ConsoleColorsValues
 from .utils import read_toml_file as read_toml_file
 from _typeshed import Incomplete
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 from functools import cached_property
 from logfire.exceptions import LogfireConfigError as LogfireConfigError
 from pathlib import Path
-from typing import Any, Callable, TypeVar
+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]
@@ -54,6 +53,7 @@ INSPECT_ARGUMENTS: Incomplete
 IGNORE_NO_CONFIG: Incomplete
 BASE_URL: Incomplete
 DISTRIBUTED_TRACING: Incomplete
+EMIT_CONFIGURATION_SPAN: Incomplete
 HTTPX_CAPTURE_ALL: Incomplete
 AIOHTTP_CLIENT_CAPTURE_ALL: Incomplete
 CONFIG_PARAMS: Incomplete

{logfire_api-4.32.1 → logfire_api-4.34.0}/logfire_api/_internal/constants.pyi

@@ -22,7 +22,9 @@ ATTRIBUTES_LOGGING_ARGS_KEY: Incomplete
 ATTRIBUTES_LOGGING_NAME: Incomplete
 ATTRIBUTES_VALIDATION_ERROR_KEY: str
 ATTRIBUTES_SCRUBBED_KEY: Incomplete
-RESOURCE_ATTRIBUTES_PACKAGE_VERSIONS: str
+ATTRIBUTES_CONFIG: str
+ATTRIBUTES_PACKAGE_VERSIONS: str
+RESOURCE_ATTRIBUTES_VERSION: str
 RESOURCE_ATTRIBUTES_DEPLOYMENT_ENVIRONMENT_NAME: str
 RESOURCE_ATTRIBUTES_VCS_REPOSITORY_REF_REVISION: str
 RESOURCE_ATTRIBUTES_VCS_REPOSITORY_URL: str

{logfire_api-4.32.1 → logfire_api-4.34.0}/logfire_api/_internal/exporters/otlp.pyi

@@ -1,3 +1,4 @@
+import atexit
 import requests
 from ..utils import logger as logger, platform_is_emscripten as platform_is_emscripten
 from .wrapper import WrapperLogExporter as WrapperLogExporter, WrapperSpanExporter as WrapperSpanExporter
@@ -14,6 +15,9 @@ from requests import Session
 from threading import Thread
 from typing import Any
 
+@atexit.register
+def cleanup_disk_retryers() -> None: ...
+
 class BodySizeCheckingOTLPSpanExporter(OTLPSpanExporter):
     max_body_size: Incomplete
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
@@ -24,6 +28,7 @@ class OTLPExporterHttpSession(Session):
     def post(self, url: str, data: bytes, **kwargs: Any): ...
     @cached_property
     def retryer(self) -> DiskRetryer: ...
+    def close(self) -> None: ...
 
 def raise_for_retryable_status(response: requests.Response): ...
 
@@ -36,10 +41,12 @@ class DiskRetryer:
     thread: Thread | None
     tasks: deque[tuple[Path, dict[str, Any]]]
     total_size: int
+    closed: bool
     session: Incomplete
     dir: Incomplete
     last_log_time: Incomplete
     def __init__(self, headers: Mapping[str, str | bytes]) -> None: ...
+    def close(self) -> None: ...
     def add_task(self, data: bytes, kwargs: dict[str, Any]): ...
 
 class RetryFewerSpansSpanExporter(WrapperSpanExporter):

logfire_api-4.34.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.32.1 → logfire_api-4.34.0}/logfire_api/_internal/instrument.pyi

@@ -1,12 +1,12 @@
-from .constants import ATTRIBUTES_MESSAGE_TEMPLATE_KEY as ATTRIBUTES_MESSAGE_TEMPLATE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY
+from .constants import ATTRIBUTES_LOG_LEVEL_NUM_KEY as ATTRIBUTES_LOG_LEVEL_NUM_KEY, ATTRIBUTES_MESSAGE_TEMPLATE_KEY as ATTRIBUTES_MESSAGE_TEMPLATE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY, LevelName as LevelName, log_level_attributes as log_level_attributes
 from .main import Logfire as Logfire
 from .stack_info import get_filepath_attribute as get_filepath_attribute
 from .utils import safe_repr as safe_repr, uniquify_sequence as uniquify_sequence
 from _typeshed import Incomplete
-from collections.abc import Iterable, Sequence
+from collections.abc import Callable, Iterable, Sequence
 from contextlib import AbstractContextManager as AbstractContextManager
 from opentelemetry.util import types as otel_types
-from typing import Any, Callable, TypeVar
+from typing import Any, TypeVar
 from typing_extensions import LiteralString, ParamSpec
 
 P = ParamSpec('P')
@@ -15,6 +15,6 @@ CONTEXTMANAGER_HELPER_CODE: Incomplete
 ASYNCCONTEXTMANAGER_HELPER_CODE: Incomplete
 GENERATOR_WARNING_MESSAGE: str
 
-def instrument(logfire: Logfire, tags: Sequence[str], msg_template: LiteralString | None, span_name: str | None, extract_args: bool | Iterable[str], record_return: bool, allow_generator: bool, new_trace: bool) -> Callable[[Callable[P, R]], Callable[P, R]]: ...
-def get_open_span(logfire: Logfire, attributes: dict[str, otel_types.AttributeValue], span_name: str | None, extract_args: bool | Iterable[str], func: Callable[P, R], new_trace: bool) -> Callable[P, AbstractContextManager[Any]]: ...
+def instrument(logfire: Logfire, tags: Sequence[str], msg_template: LiteralString | None, span_name: str | None, extract_args: bool | Iterable[str], record_return: bool, allow_generator: bool, new_trace: bool, level: LevelName | int | None = None) -> Callable[[Callable[P, R]], Callable[P, R]]: ...
+def get_open_span(logfire: Logfire, attributes: dict[str, otel_types.AttributeValue], span_name: str | None, extract_args: bool | Iterable[str], func: Callable[P, R], new_trace: bool, level: LevelName | int | None = None) -> Callable[P, AbstractContextManager[Any]]: ...
 def get_attributes(func: Any, msg_template: str | None, tags: Sequence[str] | None) -> dict[str, otel_types.AttributeValue]: ...