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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logfire-api
-Version: 4.32.0
+Version: 4.33.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

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

@@ -322,5 +322,5 @@ except ImportError:
         def get_context(*args, **kwargs) -> dict[str, Any]:
             return {}
 
-        def attach_context(*args, **kwargs)-> ContextManager[None]:
+        def attach_context(*args, **kwargs) -> ContextManager[None]:
             return nullcontext()

{logfire_api-4.32.0 → logfire_api-4.33.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.0 → logfire_api-4.33.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.0 → logfire_api-4.33.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.0 → logfire_api-4.33.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.33.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.33.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.33.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.33.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.0 → logfire_api-4.33.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.0 → logfire_api-4.33.0}/logfire_api/_internal/config.pyi

@@ -1,15 +1,14 @@
-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
@@ -19,15 +18,17 @@ 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 +41,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 +69,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
@@ -289,7 +292,13 @@ 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: ...
 
 original_os_exit: Incomplete

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

@@ -3,12 +3,12 @@ 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
@@ -54,6 +54,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.0 → logfire_api-4.33.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.0 → logfire_api-4.33.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.32.0 → logfire_api-4.33.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]: ...

{logfire_api-4.32.0 → logfire_api-4.33.0}/logfire_api/_internal/integrations/aiohttp_client.pyi

@@ -1,6 +1,7 @@
 from _typeshed import Incomplete
 from aiohttp.client_reqrep import ClientResponse
 from aiohttp.tracing import TraceRequestEndParams, TraceRequestExceptionParams, TraceRequestStartParams
+from collections.abc import Callable
 from email.headerregistry import ContentTypeHeader
 from logfire import Logfire as Logfire, LogfireSpan as LogfireSpan
 from logfire._internal.config import GLOBAL_CONFIG as GLOBAL_CONFIG
@@ -9,7 +10,7 @@ from logfire._internal.stack_info import warn_at_user_stacklevel as warn_at_user
 from logfire._internal.utils import handle_internal_errors as handle_internal_errors
 from logfire.integrations.aiohttp_client import AioHttpRequestHeaders as AioHttpRequestHeaders, AioHttpResponseHeaders as AioHttpResponseHeaders, RequestHook as RequestHook, ResponseHook as ResponseHook
 from opentelemetry.trace import Span
-from typing import Any, Callable, Literal, ParamSpec
+from typing import Any, Literal, ParamSpec
 from yarl import URL
 
 P = ParamSpec('P')

{logfire_api-4.32.0 → logfire_api-4.33.0}/logfire_api/_internal/integrations/asgi.pyi

@@ -1,4 +1,4 @@
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from logfire import Logfire as Logfire
 from logfire._internal.constants import log_level_attributes as log_level_attributes
@@ -6,7 +6,7 @@ from logfire._internal.utils import is_asgi_send_receive_span_name as is_asgi_se
 from opentelemetry.context import Context
 from opentelemetry.trace import Span, SpanKind, Tracer, TracerProvider
 from opentelemetry.util import types as otel_types
-from typing import Any, Callable, Protocol, TypedDict
+from typing import Any, Protocol, TypedDict
 from typing_extensions import Unpack
 
 Scope = dict[str, Any]

{logfire_api-4.32.0 → logfire_api-4.33.0}/logfire_api/_internal/integrations/aws_lambda.pyi

@@ -1,7 +1,8 @@
+from collections.abc import Callable
 from opentelemetry.context import Context as Context
 from opentelemetry.metrics import MeterProvider
 from opentelemetry.trace import TracerProvider
-from typing import Any, Callable
+from typing import Any
 
 LambdaEvent = Any
 LambdaHandler = Callable[[LambdaEvent, Any], Any]

{logfire_api-4.32.0 → logfire_api-4.33.0}/logfire_api/_internal/integrations/django.pyi

@@ -1,7 +1,8 @@
+from collections.abc import Callable
 from django.http import HttpRequest as HttpRequest, HttpResponse as HttpResponse
 from logfire._internal.utils import maybe_capture_server_headers as maybe_capture_server_headers
 from opentelemetry.trace import Span as Span
-from typing import Any, Callable
+from typing import Any
 
 def instrument_django(*, capture_headers: bool, is_sql_commentor_enabled: bool | None, excluded_urls: str | None, request_hook: Callable[[Span, HttpRequest], None] | None, response_hook: Callable[[Span, HttpRequest, HttpResponse], None] | None, **kwargs: Any) -> None:
     """Instrument the `django` module so that spans are automatically created for each web request.

{logfire_api-4.32.0 → logfire_api-4.33.0}/logfire_api/_internal/integrations/executors.pyi

@@ -1,8 +1,9 @@
 from ..stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
 from _typeshed import Incomplete
+from collections.abc import Callable
 from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
 from logfire.propagate import ContextCarrier as ContextCarrier, attach_context as attach_context, get_context as get_context
-from typing import Any, Callable
+from typing import Any
 
 submit_t_orig: Incomplete
 submit_p_orig: Incomplete

{logfire_api-4.32.0 → logfire_api-4.33.0}/logfire_api/_internal/integrations/fastapi.pyi

@@ -4,14 +4,14 @@ from ..stack_info import StackInfo as StackInfo, get_code_object_info as get_cod
 from ..utils import handle_internal_errors as handle_internal_errors, maybe_capture_server_headers as maybe_capture_server_headers
 from .asgi import tweak_asgi_spans_tracer_provider as tweak_asgi_spans_tracer_provider
 from _typeshed import Incomplete
-from collections.abc import Awaitable, Iterable
+from collections.abc import Awaitable, Callable, Iterable
 from contextlib import AbstractContextManager, contextmanager
 from fastapi import FastAPI
 from functools import lru_cache
 from opentelemetry.trace import Span
 from starlette.requests import Request
 from starlette.websockets import WebSocket
-from typing import Any, Callable
+from typing import Any
 
 def find_mounted_apps(app: FastAPI) -> list[FastAPI]:
     """Fetch all sub-apps mounted to a FastAPI app, including nested sub-apps."""

{logfire_api-4.32.0 → logfire_api-4.33.0}/logfire_api/_internal/integrations/httpx.pyi

@@ -1,7 +1,7 @@
 import contextlib
 import httpx
 from _typeshed import Incomplete
-from collections.abc import Awaitable as Awaitable, Generator, Mapping
+from collections.abc import Awaitable as Awaitable, Callable, Generator, Mapping
 from email.headerregistry import ContentTypeHeader
 from functools import cached_property, lru_cache
 from logfire import Logfire as Logfire, LogfireSpan as LogfireSpan
@@ -11,7 +11,7 @@ from logfire._internal.stack_info import warn_at_user_stacklevel as warn_at_user
 from logfire._internal.utils import handle_internal_errors as handle_internal_errors
 from logfire.integrations.httpx import AsyncRequestHook as AsyncRequestHook, AsyncResponseHook as AsyncResponseHook, RequestHook as RequestHook, RequestInfo as RequestInfo, ResponseHook as ResponseHook, ResponseInfo as ResponseInfo
 from opentelemetry.trace import Span
-from typing import Any, Callable, Literal, ParamSpec
+from typing import Any, Literal, ParamSpec
 
 P = ParamSpec('P')
 

{logfire_api-4.32.0 → logfire_api-4.33.0}/logfire_api/_internal/integrations/pymongo.pyi

@@ -1,6 +1,7 @@
+from collections.abc import Callable
 from opentelemetry.sdk.trace import Span as Span
 from pymongo.monitoring import CommandFailedEvent as CommandFailedEvent, CommandStartedEvent as CommandStartedEvent, CommandSucceededEvent as CommandSucceededEvent
-from typing import Any, Callable
+from typing import Any
 
 def instrument_pymongo(*, capture_statement: bool, request_hook: Callable[[Span, CommandStartedEvent], None] | None = None, response_hook: Callable[[Span, CommandSucceededEvent], None] | None = None, failed_hook: Callable[[Span, CommandFailedEvent], None] | None = None, **kwargs: Any) -> None:
     """Instrument the `pymongo` module so that spans are automatically created for each operation.

{logfire_api-4.32.0 → logfire_api-4.33.0}/logfire_api/_internal/integrations/requests.pyi

@@ -1,6 +1,7 @@
 import requests
+from collections.abc import Callable
 from opentelemetry.sdk.trace import Span as Span
-from typing import Any, Callable
+from typing import Any
 
 def instrument_requests(excluded_urls: str | None = None, request_hook: Callable[[Span, requests.PreparedRequest], None] | None = None, response_hook: Callable[[Span, requests.PreparedRequest, requests.Response], None] | None = None, **kwargs: Any) -> None:
     """Instrument the `requests` module so that spans are automatically created for each request.

{logfire_api-4.32.0 → logfire_api-4.33.0}/logfire_api/_internal/integrations/surrealdb.pyi

@@ -8,4 +8,4 @@ from typing import Any
 def get_all_surrealdb_classes() -> set[type]: ...
 def instrument_surrealdb(obj: SyncTemplate | AsyncTemplate | type[SyncTemplate] | type[AsyncTemplate] | None, logfire_instance: Logfire): ...
 @handle_internal_errors
-def patch_method(obj: Any, method_name: str, logfire_instance: Logfire): ...
+def patch_method(obj: Any, method_name: str, template_method: Any, logfire_instance: Logfire): ...

{logfire_api-4.32.0 → logfire_api-4.33.0}/logfire_api/_internal/json_formatter.pyi

@@ -1,6 +1,7 @@
 from .json_types import ArraySchema as ArraySchema, DataType as DataType, JSONSchema as JSONSchema
 from .utils import safe_repr as safe_repr
 from _typeshed import Incomplete
+from collections.abc import Callable as Callable
 from typing import Any
 
 class JsonArgsValueFormatter:

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

@@ -34,6 +34,7 @@ from .metrics import ProxyMeterProvider as ProxyMeterProvider
 from .stack_info import get_user_stack_info as get_user_stack_info
 from .tracer import ProxyTracerProvider as ProxyTracerProvider, _ProxyTracer, set_exception_status as set_exception_status
 from .utils import SysExcInfo as SysExcInfo, get_version as get_version, handle_internal_errors as handle_internal_errors, log_internal_error as log_internal_error, uniquify_sequence as uniquify_sequence
+from anthropic.lib.bedrock import AnthropicBedrock as _AnthropicBedrock, AsyncAnthropicBedrock as _AsyncAnthropicBedrock
 from collections.abc import Iterable, Mapping, Sequence
 from contextlib import AbstractContextManager
 from django.http import HttpRequest as HttpRequest, HttpResponse as HttpResponse
@@ -250,7 +251,7 @@ class Logfire:
                 Attributes starting with an underscore are not allowed.
         """
     @overload
-    def instrument(self, msg_template: LiteralString | None = None, *, span_name: str | None = None, extract_args: bool | Iterable[str] = True, record_return: bool = False, allow_generator: bool = False, new_trace: bool = False) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    def instrument(self, msg_template: LiteralString | None = None, *, span_name: str | None = None, extract_args: bool | Iterable[str] = True, record_return: bool = False, allow_generator: bool = False, new_trace: bool = False, level: LevelName | int | None = None) -> Callable[[Callable[P, R]], Callable[P, R]]:
         """Decorator for instrumenting a function as a span.
 
         ```py
@@ -275,6 +276,8 @@ class Logfire:
                 Read https://logfire.pydantic.dev/docs/guides/advanced/generators/#using-logfireinstrument first.
             new_trace: Set to `True` to start a new trace with a span link to the current span
                 instead of creating a child of the current span.
+            level: The log level for the span. If provided, the span will be tagged with this level
+                and suppressed if the level is below the configured `min_level`.
         """
     @overload
     def instrument(self, func: Callable[P, R]) -> Callable[P, R]:
@@ -591,7 +594,7 @@ class Logfire:
         For instrumentation of the standard OpenAI SDK package,
         see [`instrument_openai()`][logfire.Logfire.instrument_openai].
         """
-    def instrument_anthropic(self, anthropic_client: anthropic.Anthropic | anthropic.AsyncAnthropic | anthropic.AnthropicBedrock | anthropic.AsyncAnthropicBedrock | type[anthropic.Anthropic] | type[anthropic.AsyncAnthropic] | type[anthropic.AnthropicBedrock] | type[anthropic.AsyncAnthropicBedrock] | None = None, *, suppress_other_instrumentation: bool = True, version: SemconvVersion | Sequence[SemconvVersion] = 1) -> AbstractContextManager[None]:
+    def instrument_anthropic(self, anthropic_client: anthropic.Anthropic | anthropic.AsyncAnthropic | _AnthropicBedrock | _AsyncAnthropicBedrock | type[anthropic.Anthropic] | type[anthropic.AsyncAnthropic] | type[_AnthropicBedrock] | type[_AsyncAnthropicBedrock] | None = None, *, suppress_other_instrumentation: bool = True, version: SemconvVersion | Sequence[SemconvVersion] = 1) -> AbstractContextManager[None]:
         '''Instrument an Anthropic client so that spans are automatically created for each request.
 
         The following methods are instrumented for both the sync and async clients:
@@ -697,8 +700,14 @@ class Logfire:
             A context manager that will revert the instrumentation when exited.
                 Use of this context manager is optional.
         """
-    def instrument_asyncpg(self, **kwargs: Any) -> None:
-        """Instrument the `asyncpg` module so that spans are automatically created for each query."""
+    def instrument_asyncpg(self, capture_parameters: bool = False, **kwargs: Any) -> None:
+        """Instrument the `asyncpg` module so that spans are automatically created for each query.
+
+        Args:
+            capture_parameters: Set to `True` to capture query parameters as span attributes.
+                Be cautious when enabling this, as it may lead to sensitive data being captured in traces.
+            kwargs: Additional keyword arguments to pass to the OpenTelemetry `instrument` method.
+        """
     @overload
     def instrument_httpx(self, client: httpx.Client, *, capture_all: bool = False, capture_headers: bool = False, capture_request_body: bool = False, capture_response_body: bool = False, request_hook: HttpxRequestHook | None = None, response_hook: HttpxResponseHook | None = None, **kwargs: Any) -> None: ...
     @overload