logfire-api 5.3.0__tar.gz → 5.5.0__tar.gz

{logfire_api-5.3.0 → logfire_api-5.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: logfire-api
-Version: 5.3.0
+Version: 5.5.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-5.3.0 → logfire_api-5.5.0}/logfire_api/__init__.py

@@ -17,7 +17,10 @@ except ImportError:
         VERSION = '0.0.0'
         METRICS_PREFERRED_TEMPORALITY = {}
 
-        def configure(*args, **kwargs): ...
+        def configure(*args, **kwargs) -> Logfire:
+            if kwargs.get('local'):
+                return Logfire()
+            return DEFAULT_LOGFIRE_INSTANCE
 
         class LogfireSpan:
             def __getattr__(self, attr):
@@ -155,6 +158,11 @@ except ImportError:
 
             def instrument_monty(self, *args, **kwargs) -> None: ...
 
+            def agent_sandboxes(self, *args, **kwargs) -> Any:
+                raise RuntimeError(
+                    "`logfire.agent_sandboxes()` requires the `logfire` package, install it with `pip install 'logfire[agent-sandboxes]'`"
+                )
+
             def instrument_pymongo(self, *args, **kwargs) -> None: ...
 
             def instrument_sqlalchemy(self, *args, **kwargs) -> None: ...
@@ -247,6 +255,7 @@ except ImportError:
         instrument_pydantic = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic
         instrument_pydantic_ai = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic_ai
         instrument_monty = DEFAULT_LOGFIRE_INSTANCE.instrument_monty
+        agent_sandboxes = DEFAULT_LOGFIRE_INSTANCE.agent_sandboxes
         instrument_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
         instrument_openai = DEFAULT_LOGFIRE_INSTANCE.instrument_openai
         instrument_openai_agents = DEFAULT_LOGFIRE_INSTANCE.instrument_openai_agents
@@ -283,7 +292,7 @@ except ImportError:
         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]:
+        def loguru_handler(*, console_log: bool = True) -> dict[str, Any]:
             return {}
 
         def no_auto_trace(x):

{logfire_api-5.3.0 → logfire_api-5.5.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_monty', '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_litestar', 'instrument_aiohttp_client', 'instrument_aiohttp_server', 'instrument_sqlalchemy', 'instrument_sqlite3', 'instrument_aws_lambda', 'instrument_redis', 'instrument_pymongo', 'instrument_mysql', 'instrument_surrealdb', 'instrument_snowflake', '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', 'template_var', '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']
+__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_monty', 'agent_sandboxes', '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_litestar', 'instrument_aiohttp_client', 'instrument_aiohttp_server', 'instrument_sqlalchemy', 'instrument_sqlite3', 'instrument_aws_lambda', 'instrument_redis', 'instrument_pymongo', 'instrument_mysql', 'instrument_surrealdb', 'instrument_snowflake', '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', 'template_var', '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
@@ -27,6 +27,7 @@ install_auto_tracing = DEFAULT_LOGFIRE_INSTANCE.install_auto_tracing
 instrument_pydantic = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic
 instrument_pydantic_ai = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic_ai
 instrument_monty = DEFAULT_LOGFIRE_INSTANCE.instrument_monty
+agent_sandboxes = DEFAULT_LOGFIRE_INSTANCE.agent_sandboxes
 instrument_asgi = DEFAULT_LOGFIRE_INSTANCE.instrument_asgi
 instrument_wsgi = DEFAULT_LOGFIRE_INSTANCE.instrument_wsgi
 instrument_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
@@ -86,9 +87,13 @@ variables_push_config = DEFAULT_LOGFIRE_INSTANCE.variables_push_config
 variables_pull_config = DEFAULT_LOGFIRE_INSTANCE.variables_pull_config
 variables_build_config = DEFAULT_LOGFIRE_INSTANCE.variables_build_config
 
-def loguru_handler() -> Any:
+def loguru_handler(*, console_log: bool = True) -> Any:
     """Create a **Logfire** handler for Loguru.
 
+    Args:
+        console_log: Whether Logfire also prints these logs to the console.
+            Set to `False` to keep Loguru's own console output without duplicates.
+
     Returns:
         A dictionary with the handler and format for Loguru.
     """

logfire_api-5.5.0/logfire_api/_internal/agent_sandboxes.pyi

@@ -0,0 +1,42 @@
+from collections.abc import Awaitable as Awaitable, Callable, Mapping
+from contextlib import AbstractAsyncContextManager
+from logfire import Logfire as Logfire
+from logfire.exceptions import LogfireConfigError as LogfireConfigError
+from logfire.propagate import get_context as get_context
+from pydantic_monty import AsyncMontyRemote, AsyncMontySession as AsyncMontySession, ExternalModule as ExternalModule, OSPolicy, ResourceLimits, TypeCheckFormat
+from typing import Any
+from typing_extensions import TypedDict, Unpack
+
+class AgentSandboxCheckoutOptions(TypedDict, total=False):
+    """Keyword options forwarded unchanged to AsyncMontyRemote.checkout."""
+    script_name: str
+    limits: ResourceLimits | None
+    type_check: bool
+    type_check_stubs: str | None
+    type_check_format: TypeCheckFormat | None
+    type_check_color: bool
+    assert_message_annotations: bool | int
+    print_flush_interval: float | None
+    os_policy: OSPolicy | None
+    external_modules: Mapping[str, ExternalModule | Callable[[], Awaitable[ExternalModule]]] | None
+    ephemeral: bool | None
+    profile: str | None
+
+class AgentSandboxPool:
+    """An async Monty remote pool that adds Logfire hints when checkout is refused.
+
+    Monty's native pool and refusal exception cannot be subclassed. Hinted refusals raise
+    RuntimeError, with the original MontyRefusedError available as the chained cause.
+    """
+    def __init__(self, pool: AsyncMontyRemote) -> None: ...
+    async def __aenter__(self) -> AgentSandboxPool: ...
+    async def __aexit__(self, *args: Any) -> None: ...
+    def checkout(self, **kwargs: Unpack[AgentSandboxCheckoutOptions]) -> AbstractAsyncContextManager[AsyncMontySession]:
+        """Check out a session with the options and defaults of AsyncMontyRemote.checkout."""
+
+def agent_sandboxes_url(base_url: str) -> str:
+    """Validate and normalize a supplied or derived Logfire Agent Sandboxes URL.
+
+    The client opens its gRPC stream at the root of this URL, so the base URL must not have a path.
+    """
+def create_agent_sandboxes(logfire_instance: Logfire, *, api_key: str | None, url: str | None, metadata: Callable[[], Mapping[str, str]] | None = None, connect_headers: Callable[[], Mapping[str, str]] | None = None, **kwargs: Any) -> AgentSandboxPool: ...

{logfire_api-5.3.0 → logfire_api-5.5.0}/logfire_api/_internal/cli/run.pyi

@@ -4,6 +4,7 @@ from collections.abc import Callable, Collection, Generator, Mapping
 from contextlib import contextmanager
 from dataclasses import dataclass
 from logfire._internal.utils import get_version as get_version
+from opentelemetry.instrumentation.dependencies import DependencyConflict
 from rich.console import Console
 from rich.text import Text
 
@@ -48,9 +49,23 @@ def is_uv_installed() -> bool:
 def instrument_packages(installed_otel_packages: set[str], instrument_pkg_map: dict[str, str]) -> list[str]:
     """Call every `logfire.instrument_x()` we can based on what's installed.
 
+    Packages without a Logfire method fall back to their own OpenTelemetry instrumentors.
+
     Returns a list of packages that were successfully instrumented.
     """
 def instrument_package(import_name: str, *args: str) -> None: ...
+def warn_on_version_conflict(source: str, conflict: DependencyConflict) -> None:
+    """Warn when an instrumented library is installed at a version its instrumentation doesn't support.
+
+    A library that isn't installed at all is skipped quietly, as `opentelemetry-instrument` does.
+    """
+def instrument_with_entry_points(otel_pkg_name: str) -> bool:
+    """Call the `opentelemetry_instrumentor` entry points registered by an OpenTelemetry instrumentation package.
+
+    This follows `opentelemetry-instrument`, but passes Logfire's providers and warns on every failure,
+    including a missing module, where `opentelemetry-instrument` raises or only logs.
+    Returns whether at least one instrumentor was activated.
+    """
 def find_recommended_instrumentations_to_install(instrument_pkg_map: dict[str, str], installed_otel_pkgs: set[str], installed_pkgs: set[str], installed_versions: Mapping[str, str] | None = None) -> set[InstrumentationRecommendation]:
     """Determine which OpenTelemetry instrumentation packages are recommended for installation.
 

{logfire_api-5.3.0 → logfire_api-5.5.0}/logfire_api/_internal/config.pyi

@@ -6,6 +6,7 @@ from ..types import ExceptionCallback as ExceptionCallback
 from .client import InvalidProjectName as InvalidProjectName, LogfireClient as LogfireClient, ProjectAlreadyExists as ProjectAlreadyExists
 from .config_params import CompressionValues as CompressionValues, ParamManager as ParamManager, PydanticPluginRecordValues as PydanticPluginRecordValues, normalize_token as normalize_token
 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.api_key_gate import ApiKeyGatedLogExporter as ApiKeyGatedLogExporter, ApiKeyGatedMetricExporter as ApiKeyGatedMetricExporter, ApiKeyGatedSpanExporter as ApiKeyGatedSpanExporter, ApiKeyWriteAccess as ApiKeyWriteAccess
 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
@@ -14,6 +15,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 .fleet import FleetOptions as FleetOptions, LogfireFleetWarning as LogfireFleetWarning, load_fleet as load_fleet
 from .forwarding import OTLPForwardingManager as OTLPForwardingManager
 from .http_transport import install_connection_policy as install_connection_policy
 from .integrations.executors import instrument_executors as instrument_executors
@@ -53,6 +55,7 @@ from typing_extensions import Self
 
 CREDENTIALS_FILENAME: str
 COMMON_REQUEST_HEADERS: Incomplete
+API_KEY_CANNOT_WRITE_HINT: str
 PROJECT_NAME_PATTERN: str
 METRICS_PREFERRED_TEMPORALITY: Incomplete
 
@@ -145,7 +148,7 @@ class LocalVariablesOptions:
     instrument: bool = ...
     template_mismatch_policy: TemplateMismatchPolicy = ...
 
-def configure(*, local: bool = False, send_to_logfire: bool | Literal['if-token-present'] | None = None, token: str | list[str] | None = None, api_key: str | None = None, service_name: str | None = None, service_version: str | None = None, environment: str | None = None, resource_attributes: Mapping[str, Any] | None = None, console: ConsoleOptions | Literal[False] | None = None, config_dir: Path | str | None = None, data_dir: Path | str | None = None, additional_span_processors: Sequence[SpanProcessor] | None = None, metrics: MetricsOptions | Literal[False] | None = None, scrubbing: ScrubbingOptions | Literal[False] | None = None, inspect_arguments: bool | None = None, sampling: SamplingOptions | None = None, min_level: int | LevelName | None = None, add_baggage_to_attributes: bool = True, code_source: CodeSource | None = None, variables: VariablesOptions | LocalVariablesOptions | None = None, distributed_tracing: bool | None = None, advanced: AdvancedOptions | None = None) -> Logfire:
+def configure(*, local: bool = False, send_to_logfire: bool | Literal['if-token-present'] | None = None, token: str | list[str] | None = None, api_key: str | None = None, service_name: str | None = None, service_version: str | None = None, environment: str | None = None, resource_attributes: Mapping[str, Any] | None = None, console: ConsoleOptions | Literal[False] | None = None, config_dir: Path | str | None = None, data_dir: Path | str | None = None, additional_span_processors: Sequence[SpanProcessor] | None = None, metrics: MetricsOptions | Literal[False] | None = None, scrubbing: ScrubbingOptions | Literal[False] | None = None, inspect_arguments: bool | None = None, sampling: SamplingOptions | None = None, min_level: int | LevelName | None = None, add_baggage_to_attributes: bool = True, code_source: CodeSource | None = None, variables: VariablesOptions | LocalVariablesOptions | None = None, distributed_tracing: bool | None = None, fleet: bool | FleetOptions | None = None, advanced: AdvancedOptions | None = None) -> Logfire:
     """Configure the logfire SDK.
 
     Args:
@@ -165,6 +168,10 @@ def configure(*, local: bool = False, send_to_logfire: bool | Literal['if-token-
 
             If not provided, will be loaded from the `LOGFIRE_API_KEY` environment variable.
 
+            If no write token or project credentials file is found, the API key is also used to send
+            telemetry, unless `send_to_logfire` is `False`. This requires a project API key with the
+            `project:write_otlp` scope. Otherwise Logfire warns that the key cannot send telemetry.
+
         service_name: Name of this service.
 
             Defaults to the `LOGFIRE_SERVICE_NAME` environment variable.
@@ -221,12 +228,20 @@ def configure(*, local: bool = False, send_to_logfire: bool | Literal['if-token-
             See the [Baggage documentation](https://logfire.pydantic.dev/docs/reference/advanced/baggage/) for more details.
         code_source: Settings for the source code of the project.
         variables: Options related to managed variables.
-        distributed_tracing: By default, incoming trace context is extracted, but generates a warning.
+        distributed_tracing: By default, incoming context is extracted, but generates a warning.
             Set to `True` to disable the warning.
-            Set to `False` to suppress extraction of incoming trace context.
+            Set to `False` to suppress extraction of all incoming context, preserving local context.
             See [Unintentional Distributed Tracing](https://logfire.pydantic.dev/docs/how-to-guides/distributed-tracing/#unintentional-distributed-tracing)
             for more information.
             This setting always applies globally, and the last value set is used, including the default value.
+        fleet: Whether to manage this SDK from Logfire Fleet: the Fleet policy then applies to everything it sends
+            (sampling, which signals are sent, log levels, redaction and volume limits, the console included).
+            `True` takes the Fleet server from the `OTEL_OPAMP_*` environment variables; a
+            [`FleetOptions`][logfire.fleet.FleetOptions] gives it in code. Needs the 'fleet' extra.
+            It never blocks or raises: until Fleet answers, the last policy saved is in force, else the SDK's own
+            settings, and where Fleet can't be joined it warns and the SDK runs unmanaged.
+
+            Defaults to the `LOGFIRE_FLEET` environment variable, otherwise `False`.
         advanced: Advanced options primarily used for testing by Logfire developers.
     """
 
@@ -259,17 +274,18 @@ class _LogfireConfigData:
     code_source: CodeSource | None
     variables: VariablesOptions | LocalVariablesOptions | None
     distributed_tracing: bool | None
+    fleet: FleetOptions | Literal[False]
     advanced: AdvancedOptions
 
 class LogfireConfig(_LogfireConfigData):
-    def __init__(self, send_to_logfire: bool | Literal['if-token-present'] | None = None, token: str | list[str] | None = None, api_key: str | None = None, service_name: str | None = None, service_version: str | None = None, environment: str | None = None, resource_attributes: Mapping[str, Any] | None = None, console: ConsoleOptions | Literal[False] | None = None, config_dir: Path | None = None, data_dir: Path | None = None, additional_span_processors: Sequence[SpanProcessor] | None = None, metrics: MetricsOptions | Literal[False] | None = None, scrubbing: ScrubbingOptions | Literal[False] | None = None, inspect_arguments: bool | None = None, sampling: SamplingOptions | None = None, min_level: int | LevelName | None = None, add_baggage_to_attributes: bool = True, variables: VariablesOptions | None = None, code_source: CodeSource | None = None, distributed_tracing: bool | None = None, advanced: AdvancedOptions | None = None) -> None:
+    def __init__(self, send_to_logfire: bool | Literal['if-token-present'] | None = None, token: str | list[str] | None = None, api_key: str | None = None, service_name: str | None = None, service_version: str | None = None, environment: str | None = None, resource_attributes: Mapping[str, Any] | None = None, console: ConsoleOptions | Literal[False] | None = None, config_dir: Path | None = None, data_dir: Path | None = None, additional_span_processors: Sequence[SpanProcessor] | None = None, metrics: MetricsOptions | Literal[False] | None = None, scrubbing: ScrubbingOptions | Literal[False] | None = None, inspect_arguments: bool | None = None, sampling: SamplingOptions | None = None, min_level: int | LevelName | None = None, add_baggage_to_attributes: bool = True, variables: VariablesOptions | None = None, code_source: CodeSource | None = None, distributed_tracing: bool | None = None, advanced: AdvancedOptions | None = None, fleet: bool | FleetOptions | None = None) -> None:
         """Create a new LogfireConfig.
 
         Users should never need to call this directly, instead use `logfire.configure`.
 
         See `_LogfireConfigData` for parameter documentation.
         """
-    def configure(self, send_to_logfire: bool | Literal['if-token-present'] | None, token: str | list[str] | None, api_key: str | None, service_name: str | None, service_version: str | None, environment: str | None, resource_attributes: Mapping[str, Any] | None, console: ConsoleOptions | Literal[False] | None, config_dir: Path | None, data_dir: Path | None, additional_span_processors: Sequence[SpanProcessor] | None, metrics: MetricsOptions | Literal[False] | None, scrubbing: ScrubbingOptions | Literal[False] | None, inspect_arguments: bool | None, sampling: SamplingOptions | None, min_level: int | LevelName | None, add_baggage_to_attributes: bool, code_source: CodeSource | None, variables: VariablesOptions | LocalVariablesOptions | None, distributed_tracing: bool | None, advanced: AdvancedOptions | None) -> None: ...
+    def configure(self, send_to_logfire: bool | Literal['if-token-present'] | None, token: str | list[str] | None, api_key: str | None, service_name: str | None, service_version: str | None, environment: str | None, resource_attributes: Mapping[str, Any] | None, console: ConsoleOptions | Literal[False] | None, config_dir: Path | None, data_dir: Path | None, additional_span_processors: Sequence[SpanProcessor] | None, metrics: MetricsOptions | Literal[False] | None, scrubbing: ScrubbingOptions | Literal[False] | None, inspect_arguments: bool | None, sampling: SamplingOptions | None, min_level: int | LevelName | None, add_baggage_to_attributes: bool, code_source: CodeSource | None, variables: VariablesOptions | LocalVariablesOptions | None, distributed_tracing: bool | None, fleet: bool | FleetOptions | None, advanced: AdvancedOptions | None) -> None: ...
     def initialize(self) -> None:
         """Configure internals to start exporting traces and metrics."""
     def force_flush(self, timeout_millis: int = 30000) -> bool:
@@ -359,13 +375,16 @@ class LogfireCredentials:
             LogfireConfigError: If the credentials file exists but is invalid.
         """
     @classmethod
-    def from_token(cls, token: str, session: requests.Session, base_url: str) -> Self | None:
+    def from_token(cls, token: str, session: requests.Session, base_url: str, *, rejected_hint: str | None = None, on_rejected: Callable[[], None] | None = None) -> Self | None:
         """Check that the token is valid.
 
         Issue a warning if the Logfire API is unreachable, or we get a response other than 200 or 401.
 
         We continue unless we get a 401. If something is wrong, we'll later store data locally for back-fill.
 
+        `rejected_hint` is appended to the warning when the API rejects the token with a 401.
+        `on_rejected` is called for that 401 too.
+
         Raises:
             LogfireConfigError: If the token is invalid.
         """
@@ -407,19 +426,6 @@ class LogfireCredentials:
         Raises:
             LogfireConfigError: If there was an error creating projects.
         """
-    @classmethod
-    def initialize_project(cls, *, client: LogfireClient) -> Self:
-        """Create a new project or use an existing project on logfire.dev requesting the given project name.
-
-        Args:
-            client: The Logfire client to use when making requests.
-
-        Returns:
-            The new credentials.
-
-        Raises:
-            LogfireConfigError: If there was an error on creating/configuring the project.
-        """
     def write_creds_file(self, creds_dir: Path) -> None:
         """Write a credentials file to the given path."""
     def print_token_summary(self) -> None:

{logfire_api-5.3.0 → logfire_api-5.5.0}/logfire_api/_internal/config_params.pyi

@@ -59,6 +59,7 @@ BASE_URL: Incomplete
 DISTRIBUTED_TRACING: Incomplete
 EMIT_CONFIGURATION_SPAN: Incomplete
 PENDING_SPANS: Incomplete
+FLEET: Incomplete
 COMPRESSION: Incomplete
 HTTPX_CAPTURE_ALL: Incomplete
 AIOHTTP_CLIENT_CAPTURE_ALL: Incomplete

{logfire_api-5.3.0 → logfire_api-5.5.0}/logfire_api/_internal/db_statement_summary.pyi

@@ -26,6 +26,11 @@ def summarize_query(db_statement: str) -> str | None:
 
     """
 def select(expr: str, table: str, *, match_end: int, db_statement: str, ctes: str | None = None, sub_query: str | None = None) -> str: ...
+def outside_parentheses(s: str) -> str:
+    """Remove everything inside parentheses, including the parentheses themselves.
+
+    Parentheses inside quoted strings or identifiers don't change the nesting depth.
+    """
 def truncate(s: str, length: int) -> str: ...
 
 FALLBACK_HALF: Incomplete

logfire_api-5.5.0/logfire_api/_internal/exporters/api_key_gate.pyi

@@ -0,0 +1,40 @@
+from .wrapper import WrapperLogExporter as WrapperLogExporter, WrapperMetricExporter as WrapperMetricExporter, WrapperSpanExporter as WrapperSpanExporter
+from _typeshed import Incomplete
+from collections.abc import Sequence
+from opentelemetry.sdk._logs import ReadableLogRecord as ReadableLogRecord
+from opentelemetry.sdk._logs.export import LogRecordExportResult, LogRecordExporter
+from opentelemetry.sdk.metrics.export import MetricExportResult, MetricExporter, MetricsData
+from opentelemetry.sdk.trace import ReadableSpan as ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExportResult, SpanExporter
+from typing import Any
+
+VERDICT_TIMEOUT_SECONDS: int
+
+class ApiKeyWriteAccess:
+    """The result of the token check for an API key that is used as a write token."""
+    def __init__(self) -> None: ...
+    def reject(self) -> None:
+        """Record that Logfire rejected the API key as a write token."""
+    def settle(self) -> None:
+        """Record that the check finished. A key that the check did not reject stays allowed."""
+    def allows_export(self) -> bool:
+        """Wait for the check, then tell if exports can use the key.
+
+        If the check does not finish in time, the export continues.
+        The exporters then report any failure as they do for a write token.
+        """
+
+class ApiKeyGatedSpanExporter(WrapperSpanExporter):
+    access: Incomplete
+    def __init__(self, exporter: SpanExporter, access: ApiKeyWriteAccess) -> None: ...
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult: ...
+
+class ApiKeyGatedLogExporter(WrapperLogExporter):
+    access: Incomplete
+    def __init__(self, exporter: LogRecordExporter, access: ApiKeyWriteAccess) -> None: ...
+    def export(self, batch: Sequence[ReadableLogRecord]) -> LogRecordExportResult: ...
+
+class ApiKeyGatedMetricExporter(WrapperMetricExporter):
+    access: Incomplete
+    def __init__(self, exporter: MetricExporter, access: ApiKeyWriteAccess, **kwargs: Any) -> None: ...
+    def export(self, metrics_data: MetricsData, timeout_millis: float = 10000, **kwargs: Any) -> MetricExportResult: ...

logfire_api-5.5.0/logfire_api/_internal/fleet.pyi

@@ -0,0 +1,30 @@
+import dataclasses
+from .stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
+from .utils import platform_is_emscripten as platform_is_emscripten
+from collections.abc import Mapping
+from datetime import timedelta
+from logfire_fleet_otel import LogfireFleet
+from pathlib import Path
+
+FLEET_CONTRACT: int
+
+@dataclasses.dataclass
+class FleetOptions:
+    """Options for joining Logfire Fleet.
+
+    Each one left as `None` comes from its environment variable, which is what the Fleet setup page
+    in Logfire gives you.
+    """
+    endpoint: str | None = ...
+    headers: Mapping[str, str] | None = ...
+    state_dir: str | Path | None = ...
+    heartbeat_interval: float | timedelta | None = ...
+
+class LogfireFleetWarning(UserWarning):
+    """The SDK couldn't join Logfire Fleet, so it runs unmanaged."""
+
+def load_fleet(options: FleetOptions) -> LogfireFleet | None:
+    """The Fleet client's hook for `options`, or `None` (with a warning) where it can't run.
+
+    It never raises: telemetry is sent either way, under the SDK's own settings.
+    """

{logfire_api-5.3.0 → logfire_api-5.5.0}/logfire_api/_internal/formatter.pyi

@@ -28,7 +28,7 @@ class ChunksFormatter(Formatter):
 chunks_formatter: Incomplete
 
 def logfire_format(format_string: str, kwargs: dict[str, Any], scrubber: BaseScrubber) -> str: ...
-def logfire_format_with_magic(format_string: str, kwargs: dict[str, Any], scrubber: BaseScrubber, fstring_frame: types.FrameType | None = None) -> tuple[str, dict[str, Any], str]: ...
+def logfire_format_with_magic(format_string: Any, kwargs: dict[str, Any], scrubber: BaseScrubber, fstring_frame: types.FrameType | None = None) -> tuple[str, dict[str, Any], str]: ...
 @lru_cache
 def compile_formatted_value(node: ast.FormattedValue, ex_source: executing.Source) -> tuple[str, CodeType, CodeType]:
     """Returns three things that can be expensive to compute.

{logfire_api-5.3.0 → logfire_api-5.5.0}/logfire_api/_internal/integrations/executors.pyi

@@ -2,9 +2,11 @@ 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 contextvars import ContextVar as ContextVar
 from logfire.propagate import ContextCarrier as ContextCarrier, attach_context as attach_context, get_context as get_context
 from typing import Any
 
+THREAD_CONTEXTVARS: list[ContextVar[Any]]
 submit_t_orig: Incomplete
 submit_p_orig: Incomplete
 

{logfire_api-5.3.0 → logfire_api-5.5.0}/logfire_api/_internal/integrations/snowflake.pyi

@@ -1,6 +1,6 @@
 from logfire import Logfire as Logfire
 from logfire._internal.stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
-from logfire._internal.utils import handle_internal_errors as handle_internal_errors
+from logfire._internal.utils import get_version as get_version, handle_internal_errors as handle_internal_errors
 from snowflake.connector.connection import SnowflakeConnection
 from types import ModuleType
 

{logfire_api-5.3.0 → logfire_api-5.5.0}/logfire_api/_internal/main.pyi

@@ -16,10 +16,11 @@ from ..integrations.sqlalchemy import CommenterOptions as SQLAlchemyCommenterOpt
 from ..integrations.wsgi import RequestHook as WSGIRequestHook, ResponseHook as WSGIResponseHook
 from ..variables import ResolveFunction as ResolveFunction, TemplateVariable as TemplateVariable, ValidationReport as ValidationReport, Variable as Variable, VariablesConfig as VariablesConfig
 from ..version import VERSION as VERSION
+from .agent_sandboxes import AgentSandboxPool as AgentSandboxPool
 from .auto_trace import AutoTraceModule as AutoTraceModule, install_auto_tracing as install_auto_tracing
 from .config import GLOBAL_CONFIG as GLOBAL_CONFIG, LogfireConfig as LogfireConfig, TemplateMismatchPolicy as TemplateMismatchPolicy
 from .config_params import PydanticPluginRecordValues as PydanticPluginRecordValues
-from .constants import ATTRIBUTES_JSON_SCHEMA_KEY as ATTRIBUTES_JSON_SCHEMA_KEY, ATTRIBUTES_LOG_LEVEL_NUM_KEY as ATTRIBUTES_LOG_LEVEL_NUM_KEY, ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_MESSAGE_TEMPLATE_KEY as ATTRIBUTES_MESSAGE_TEMPLATE_KEY, ATTRIBUTES_SAMPLE_RATE_KEY as ATTRIBUTES_SAMPLE_RATE_KEY, ATTRIBUTES_SPAN_TYPE_KEY as ATTRIBUTES_SPAN_TYPE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY, DISABLE_CONSOLE_KEY as DISABLE_CONSOLE_KEY, LEVEL_NUMBERS as LEVEL_NUMBERS, LevelName as LevelName, OTLP_MAX_INT_SIZE as OTLP_MAX_INT_SIZE, log_level_attributes as log_level_attributes
+from .constants import ATTRIBUTES_JSON_SCHEMA_KEY as ATTRIBUTES_JSON_SCHEMA_KEY, ATTRIBUTES_LOG_LEVEL_NUM_KEY as ATTRIBUTES_LOG_LEVEL_NUM_KEY, ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_MESSAGE_TEMPLATE_KEY as ATTRIBUTES_MESSAGE_TEMPLATE_KEY, ATTRIBUTES_SAMPLE_RATE_KEY as ATTRIBUTES_SAMPLE_RATE_KEY, ATTRIBUTES_SPAN_TYPE_KEY as ATTRIBUTES_SPAN_TYPE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY, DISABLE_CONSOLE_KEY as DISABLE_CONSOLE_KEY, LevelName as LevelName, OTLP_MAX_INT_SIZE as OTLP_MAX_INT_SIZE, log_level_attributes as log_level_attributes
 from .formatter import logfire_format as logfire_format, logfire_format_with_magic as logfire_format_with_magic
 from .forwarding import ForwardExportRequestResponse as ForwardExportRequestResponse
 from .instrument import instrument as instrument
@@ -34,12 +35,13 @@ from .json_encoder import logfire_json_dumps as logfire_json_dumps
 from .json_schema import JsonSchemaProperties as JsonSchemaProperties, attributes_json_schema as attributes_json_schema, attributes_json_schema_properties as attributes_json_schema_properties, create_json_schema as create_json_schema
 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 .tracer import ProxyTracerProvider as ProxyTracerProvider, _ProxyTracer
 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
+from enum import Enum
 from fastapi import FastAPI
 from flask.app import Flask
 from litestar import Litestar
@@ -69,6 +71,9 @@ ExcInfo = SysExcInfo | BaseException | bool | None
 T = TypeVar('T')
 InputsT = TypeVar('InputsT')
 
+class _Unset(Enum):
+    UNSET: str
+
 class Logfire:
     """The main logfire class."""
     def __init__(self, *, config: LogfireConfig = ..., sample_rate: float | None = None, tags: Sequence[str] = (), console_log: bool = True, otel_scope: str = 'logfire') -> None: ...
@@ -244,7 +249,8 @@ class Logfire:
         ```
 
         Args:
-            msg_template: The template for the span message.
+            msg_template: A string template for the span message. Passing another type emits a formatting
+                warning and uses its `str()` representation without interpolating it.
             _span_name: The span name. If not provided, the `msg_template` will be used.
             _tags: An optional sequence of tags to include in the span.
             _level: An optional log level name.
@@ -313,7 +319,8 @@ class Logfire:
 
         Args:
             level: The level of the log.
-            msg_template: The message to log.
+            msg_template: A string message or template. Passing another type emits a formatting warning
+                and uses its `str()` representation without interpolating it.
             attributes: The attributes to bind to the log.
             tags: An optional sequence of tags to include in the log.
             exc_info: Set to an exception or a tuple as returned by [`sys.exc_info()`][sys.exc_info]
@@ -520,6 +527,66 @@ class Logfire:
         It records Monty sessions, executed code, inputs, outputs, external calls,
         exceptions, printed text, and pool metrics. Recorded values are subject to Logfire's configured scrubbing.
         """
+    def agent_sandboxes(self, *, api_key: str | None = None, url: str | None = None, max_processes: int | None | _Unset = ..., checkout_timeout: float | None | _Unset = ..., request_timeout: float | None | _Unset = ..., metadata: Callable[[], Mapping[str, str]] | None | _Unset = ..., connect_headers: Callable[[], Mapping[str, str]] | None | _Unset = ..., feed_duration_limit_grace: float | None | _Unset = ..., turn_duration_limit_grace: float | None | _Unset = ..., auto_resume: bool | _Unset = ..., **kwargs: Any) -> AgentSandboxPool:
+        """Connect to Logfire Agent Sandboxes, remote Pydantic Monty workers hosted by Logfire.
+
+        Requires the `agent-sandboxes` extra, e.g. `pip install 'logfire[agent-sandboxes]'`.
+
+        Returns a wrapper around a [`pydantic_monty.AsyncMontyRemote`][pydantic_monty.AsyncMontyRemote] pool;
+        use it as an async context manager and check out sessions from it:
+
+        ```py
+        import logfire
+
+        logfire.configure()
+
+
+        async def main():
+            async with logfire.agent_sandboxes() as pool:
+                async with pool.checkout() as session:
+                    result = await session.feed_run('1 + 1')
+        ```
+
+        No connection is made until a session is checked out.
+
+        Checkout accepts the same options and yields the same Monty sessions as `AsyncMontyRemote`.
+        Authentication and capacity refusals raise `RuntimeError` with Logfire hints, chained from
+        the original `MontyRefusedError`. Other errors pass through unchanged.
+
+        The Logfire platform records sandbox usage itself. The current trace context is sent
+        with each session so those spans join the caller's trace.
+
+        Omitted pool options use the defaults of the installed `pydantic-monty-client` version.
+        The defaults described below are the currently assumed defaults and may change in future versions.
+
+        Args:
+            api_key: A Logfire project API key (not a personal key) with the
+                `project:execute_agent_sandboxes` scope. Agent Sandboxes must be enabled for the project.
+                Defaults to the `api_key` passed to [`configure()`][logfire.configure],
+                then the `LOGFIRE_API_KEY` environment variable.
+            url: The `https://` URL of the sandboxes server.
+                Defaults to the Logfire region the API key belongs to. Must not contain a path,
+                query, or fragment. `/monty-ws/` was the old path and must be removed.
+            max_processes: Cap on concurrent sandbox sessions. Defaults to `None`, which uses
+                the CPU count; checkouts beyond it wait.
+            checkout_timeout: Seconds `checkout()` waits for capacity before raising `TimeoutError`.
+                Defaults to `None`, which waits forever.
+            request_timeout: Hard per-turn deadline in seconds. A sandbox that exceeds it has its
+                session closed and the call raises `MontyCrashedError`. Must be finite;
+                `None` raises `LogfireConfigError` because hosted sandboxes require a deadline.
+                Defaults to `10.0`. Raise this when installing dependencies in a sandbox.
+            metadata: Called once per session to produce extra request metadata for its gRPC
+                stream. Names are lowercased and values must be ASCII. These are merged with the
+                `authorization` entry and win on conflicts.
+            connect_headers: The deprecated name of `metadata`.
+                Defaults to `None`, which adds no extra headers beyond Logfire authentication.
+            feed_duration_limit_grace: Seconds to wait past a feed's `max_feed_duration_secs`
+                before closing the sandbox. Defaults to `1.0`; `None` disables this backstop.
+            turn_duration_limit_grace: The same, for `max_turn_duration_secs`. Defaults to `1.0`.
+            auto_resume: When the server drains a stored session, transparently resume it on
+                another server instead of raising `MontyShutdown`. Defaults to `True`.
+            kwargs: Additional keyword arguments passed to `AsyncMontyRemote` for future compatibility.
+        """
     def instrument_fastapi(self, app: FastAPI, *, capture_headers: bool = False, request_attributes_mapper: Callable[[Request | WebSocket, dict[str, Any]], dict[str, Any] | None] | None = None, excluded_urls: str | Iterable[str] | None = None, record_send_receive: bool = False, extra_spans: bool = False, **opentelemetry_kwargs: Any) -> AbstractContextManager[None]:
         """Instrument a FastAPI app so that spans and logs are automatically created for each request.
 
@@ -590,7 +657,7 @@ class Logfire:
         logfire.instrument_openai(client)
 
         response = client.chat.completions.create(
-            model=\'gpt-4\',
+            model=\'gpt-5-mini\',
             messages=[
                 {\'role\': \'system\', \'content\': \'You are a helpful assistant.\'},
                 {\'role\': \'user\', \'content\': \'What is four plus five?\'},
@@ -641,7 +708,7 @@ class Logfire:
 
         - [`client.messages.create`](https://docs.anthropic.com/en/api/messages)
         - [`client.messages.stream`](https://docs.anthropic.com/en/api/messages-streaming)
-        - [`client.beta.tools.messages.create`](https://docs.anthropic.com/en/docs/tool-use)
+        - [`client.beta.messages.create`](https://docs.anthropic.com/en/docs/tool-use)
 
         When `stream=True` a second span is created to instrument the streamed response.
 
@@ -658,7 +725,7 @@ class Logfire:
         logfire.instrument_anthropic(client)
 
         response = client.messages.create(
-            model=\'claude-3-haiku-20240307\',
+            model=\'claude-haiku-5-5\',
             system=\'You are a helpful assistant.\',
             messages=[
                 {\'role\': \'user\', \'content\': \'What is four plus five?\'},

{logfire_api-5.3.0 → logfire_api-5.5.0}/logfire_api/_internal/tracer.pyi

@@ -2,7 +2,7 @@ import opentelemetry.trace as trace_api
 from ..types import ExceptionCallback as ExceptionCallback
 from .config import LogfireConfig as LogfireConfig
 from .constants import ATTRIBUTES_EXCEPTION_FINGERPRINT_KEY as ATTRIBUTES_EXCEPTION_FINGERPRINT_KEY, ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_MESSAGE_TEMPLATE_KEY as ATTRIBUTES_MESSAGE_TEMPLATE_KEY, ATTRIBUTES_PENDING_SPAN_REAL_PARENT_KEY as ATTRIBUTES_PENDING_SPAN_REAL_PARENT_KEY, ATTRIBUTES_SAMPLE_RATE_KEY as ATTRIBUTES_SAMPLE_RATE_KEY, ATTRIBUTES_SPAN_TYPE_KEY as ATTRIBUTES_SPAN_TYPE_KEY, ATTRIBUTES_VALIDATION_ERROR_KEY as ATTRIBUTES_VALIDATION_ERROR_KEY, log_level_attributes as log_level_attributes
-from .utils import handle_internal_errors as handle_internal_errors, is_instrumentation_suppressed as is_instrumentation_suppressed, sha256_string as sha256_string
+from .utils import handle_internal_errors as handle_internal_errors, is_instrumentation_suppressed as is_instrumentation_suppressed, safe_str as safe_str, safe_type_name as safe_type_name, sha256_string as sha256_string
 from _typeshed import Incomplete
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, field

{logfire_api-5.3.0 → logfire_api-5.5.0}/logfire_api/_internal/utils.pyi

@@ -32,6 +32,19 @@ def uniquify_sequence(seq: Sequence[T]) -> tuple[T, ...]:
     """Remove duplicates from a sequence preserving order."""
 def safe_repr(obj: Any) -> str:
     """Return some kind of non-empty string representation of an object, catching exceptions."""
+def safe_str(obj: Any) -> str:
+    """Return `str(obj)`, or a placeholder if calling `str()` itself raises.
+
+    Some objects (notably exceptions that were never fully initialised) raise from `__str__`.
+    Callers on the telemetry path must never let that abort their own work, so the placeholder
+    deliberately avoids looking anything up on the object or its class.
+    """
+def safe_type_name(obj: Any) -> str:
+    """Return the bare class name of `obj`, or a placeholder if that lookup raises.
+
+    A metaclass can turn `__name__` into a property that raises, so even reading the class
+    name is not safe on the telemetry path.
+    """
 Truncatable = TypeVar('Truncatable', str, bytes, 'list[Any]', 'tuple[Any, ...]')
 
 def truncate_string(s: str, *, max_length: int, middle: str = '...') -> str:

logfire_api-5.5.0/logfire_api/fleet/__init__.pyi

@@ -0,0 +1,3 @@
+from .._internal.fleet import FleetOptions as FleetOptions, LogfireFleetWarning as LogfireFleetWarning
+
+__all__ = ['FleetOptions', 'LogfireFleetWarning']

{logfire_api-5.3.0 → logfire_api-5.5.0}/logfire_api/integrations/logging.pyi

@@ -15,11 +15,14 @@ class LogfireLoggingHandler(LoggingHandler):
         level: The threshold level for this handler. Logging messages which are less severe than *level* will be ignored.
         fallback: A fallback handler to use when [instrumentation is suppressed](../../how-to-guides/suppress.md#suppress-instrumentation).
         logfire_instance: The Logfire instance to use when emitting logs. Defaults to the default global instance.
+        console_log: Whether logs from this handler are also printed to the console by Logfire.
+            Set to `False` if another handler already prints them, to avoid duplicates.
+            Defaults to the setting of `logfire_instance`.
     """
     custom_scope_suffix: ClassVar[str]
     fallback: Incomplete
     logfire_instance: Incomplete
-    def __init__(self, level: int | str = ..., fallback: LoggingHandler = ..., logfire_instance: Logfire | None = None) -> None: ...
+    def __init__(self, level: int | str = ..., fallback: LoggingHandler = ..., logfire_instance: Logfire | None = None, console_log: bool | None = None) -> None: ...
     def emit(self, record: LogRecord) -> None:
         """Send the log to Logfire.
 

{logfire_api-5.3.0 → logfire_api-5.5.0}/logfire_api/propagate.pyi

@@ -61,15 +61,16 @@ class WrapperPropagator(TextMapPropagator):
     def fields(self): ...
 
 class NoExtractTraceContextPropagator(WrapperPropagator):
-    """A propagator that ignores any trace context that was extracted by the wrapped propagator.
+    """A propagator that ignores all incoming context and preserves local context.
 
-    Used when `logfire.configure(distributed_tracing=False)` is called.
+    Used when `logfire.configure(distributed_tracing=False)` is called. Extraction returns the
+    supplied context, or the current context if none is supplied, without calling the wrapped propagator.
     """
     def extract(self, carrier: Any, context: otel_context.Context | None = None, *args: Any, **kwargs: Any) -> otel_context.Context: ...
 
 @dataclass
 class WarnOnExtractTraceContextPropagator(WrapperPropagator):
-    """A propagator that warns the first time that trace context is extracted by the wrapped propagator.
+    """A propagator that warns the first time that incoming context is extracted by the wrapped propagator.
 
     Used when `logfire.configure(distributed_tracing=None)` is called. This is the default behavior.
     """

{logfire_api-5.3.0 → logfire_api-5.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "logfire-api"
-version = "5.3.0"
+version = "5.5.0"
 description = "Shim for the Logfire SDK which does nothing unless Logfire is installed"
 authors = [
     { name = "Pydantic Team", email = "engineering@pydantic.dev" },