logfire-api 5.4.0__tar.gz → 5.6.0__tar.gz

{logfire_api-5.4.0 → logfire_api-5.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: logfire-api
-Version: 5.4.0
+Version: 5.6.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.4.0 → logfire_api-5.6.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):
@@ -164,7 +167,11 @@ except ImportError:
 
             def instrument_sqlalchemy(self, *args, **kwargs) -> None: ...
 
-            def instrument_sqlite3(self, *args, **kwargs) -> None: ...
+            def instrument_sqlite3(self, conn=None, *args, **kwargs):
+                return conn
+
+            def instrument_mysql(self, conn=None, *args, **kwargs):
+                return conn
 
             def instrument_aws_lambda(self, *args, **kwargs) -> None: ...
 
@@ -227,7 +234,8 @@ except ImportError:
             async def forward_export_request_starlette(self, *args, **kwargs) -> MagicMock:
                 return MagicMock()
 
-            def shutdown(self, *args, **kwargs) -> None: ...
+            def shutdown(self, *args, **kwargs) -> bool:
+                return True
 
         DEFAULT_LOGFIRE_INSTANCE = Logfire()
         span = DEFAULT_LOGFIRE_INSTANCE.span
@@ -289,7 +297,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.4.0 → logfire_api-5.6.0}/logfire_api/__init__.pyi

@@ -87,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.6.0/logfire_api/_internal/agent_sandboxes.pyi

@@ -0,0 +1,13 @@
+from collections.abc import Callable, Mapping as Mapping
+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
+from typing import Any
+
+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) -> AsyncMontyRemote: ...

{logfire_api-5.4.0 → logfire_api-5.6.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.4.0 → logfire_api-5.6.0}/logfire_api/_internal/config.pyi

@@ -6,14 +6,16 @@ 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
 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, zstd_compress as zstd_compress
-from .exporters.processor_wrapper import CheckSuppressInstrumentationProcessorWrapper as CheckSuppressInstrumentationProcessorWrapper, MainSpanProcessorWrapper as MainSpanProcessorWrapper
+from .exporters.processor_wrapper import BackgroundScrubbingSpanProcessor as BackgroundScrubbingSpanProcessor, CheckSuppressInstrumentationProcessorWrapper as CheckSuppressInstrumentationProcessorWrapper, MainSpanProcessorWrapper as MainSpanProcessorWrapper, ScrubbingSpanProcessor as ScrubbingSpanProcessor, SpanProcessorGroup as SpanProcessorGroup, make_scrubbing_queue as make_scrubbing_queue, scrub_span as scrub_span
 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.
@@ -197,6 +204,8 @@ def configure(*, local: bool = False, send_to_logfire: bool | Literal['if-token-
 
         data_dir: Directory to store credentials, and logs. If `None` uses the `LOGFIRE_CREDENTIALS_DIR` environment variable, otherwise defaults to `'.logfire'`.
         additional_span_processors: Span processors to use in addition to the default processor which exports spans to Logfire's API.
+            Processors which have a custom `on_end` method (other than `BatchSpanProcessor`) will cause
+            span attribute scrubbing to happen on the calling thread, which may slow down your application.
         metrics: Set to `False` to disable sending all metrics,
             or provide a `MetricsOptions` object to configure metrics, e.g. additional metric readers.
         scrubbing: Options for scrubbing sensitive data. Set to `False` to disable.
@@ -221,12 +230,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 +276,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 +377,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 +428,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.4.0 → logfire_api-5.6.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.6.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.4.0 → logfire_api-5.6.0}/logfire_api/_internal/exporters/otlp.pyi

@@ -9,7 +9,6 @@ from .wrapper import WrapperLogExporter as WrapperLogExporter, WrapperSpanExport
 from _typeshed import Incomplete
 from collections import deque
 from collections.abc import Mapping, Sequence
-from functools import cached_property
 from logfire._internal.utils import handle_internal_errors as handle_internal_errors
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk._logs import ReadableLogRecord as ReadableLogRecord
@@ -60,7 +59,7 @@ class OTLPExporterHttpSession(Session):
     def __init__(self, *, _use_zstd: bool = False) -> None: ...
     def request(self, method: str, url: str, **kwargs: Any): ...
     def post(self, url: str, data: bytes, **kwargs: Any): ...
-    @cached_property
+    @property
     def retryer(self) -> DiskRetryer: ...
     def close(self) -> None: ...
 
@@ -76,6 +75,7 @@ class DiskRetryer:
     tasks: deque[tuple[Path, dict[str, Any]]]
     total_size: int
     closed: bool
+    pid: Incomplete
     session: Incomplete
     dir: Incomplete
     last_log_time: Incomplete

{logfire_api-5.4.0 → logfire_api-5.6.0}/logfire_api/_internal/exporters/processor_wrapper.pyi

@@ -5,9 +5,11 @@ from ..json_schema import JsonSchemaProperties as JsonSchemaProperties, attribut
 from ..scrubbing import BaseScrubber as BaseScrubber
 from ..utils import ReadableSpanDict as ReadableSpanDict, handle_internal_errors as handle_internal_errors, is_asgi_send_receive_span_name as is_asgi_send_receive_span_name, is_instrumentation_suppressed as is_instrumentation_suppressed, span_to_dict as span_to_dict, truncate_string as truncate_string
 from .wrapper import WrapperSpanProcessor as WrapperSpanProcessor
+from collections.abc import Sequence
 from dataclasses import dataclass
 from opentelemetry import context
-from opentelemetry.sdk.trace import Event as Event, ReadableSpan, Span
+from opentelemetry.sdk.trace import Event as Event, ReadableSpan, Span, SpanProcessor, SynchronousMultiSpanProcessor
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanExportResult, SpanExporter
 
 class CheckSuppressInstrumentationProcessorWrapper(WrapperSpanProcessor):
     """Checks if instrumentation is suppressed, then suppresses instrumentation itself.
@@ -17,14 +19,42 @@ class CheckSuppressInstrumentationProcessorWrapper(WrapperSpanProcessor):
     def on_start(self, span: Span, parent_context: context.Context | None = None) -> None: ...
     def on_end(self, span: ReadableSpan) -> None: ...
 
-@dataclass
 class MainSpanProcessorWrapper(WrapperSpanProcessor):
     """Wrapper around other processors to intercept starting and ending spans with our own global logic.
 
     Suppresses starting/ending if the current context has a `suppress_instrumentation` value.
     Tweaks the send/receive span names generated by the ASGI middleware.
     """
+    def on_end(self, span: ReadableSpan) -> None: ...
+
+def scrub_span(span: ReadableSpan, scrubber: BaseScrubber) -> ReadableSpan: ...
+
+@dataclass
+class ScrubbingSpanProcessor(WrapperSpanProcessor):
     scrubber: BaseScrubber
     def on_end(self, span: ReadableSpan) -> None: ...
 
+@dataclass
+class _SpanProcessorExporter(SpanExporter):
+    """Forward drained records to a processor's `on_end` hook.
+
+    The group that owns the destination processor flushes and shuts it down.
+    """
+    processor: SpanProcessor
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult: ...
+
+def make_scrubbing_queue(processor: SpanProcessor, scrubber: BaseScrubber) -> BatchSpanProcessor:
+    """Queue records for scrubbing before delivering them to a processor."""
+
+class SpanProcessorGroup(SynchronousMultiSpanProcessor):
+    """Flush processors that may inherit a no-op force_flush returning None."""
+    def force_flush(self, timeout_millis: int = 30000) -> bool: ...
+
+@dataclass
+class BackgroundScrubbingSpanProcessor(WrapperSpanProcessor):
+    """Send completed spans to the synchronous processors and the scrubbing queue."""
+    synchronous_end_processor: SpanProcessor
+    background_end_processor: BatchSpanProcessor
+    def on_end(self, span: ReadableSpan) -> None: ...
+
 def guess_system(model: str, default: str = ''): ...

logfire_api-5.6.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.4.0 → logfire_api-5.6.0}/logfire_api/_internal/formatter.pyi

@@ -9,7 +9,7 @@ from _typeshed import Incomplete
 from collections.abc import Iterator
 from functools import lru_cache
 from string import Formatter
-from types import CodeType as CodeType
+from types import CodeType
 from typing import Any, Literal
 from typing_extensions import NotRequired, TypedDict
 
@@ -29,6 +29,10 @@ chunks_formatter: Incomplete
 
 def logfire_format(format_string: str, kwargs: dict[str, Any], scrubber: BaseScrubber) -> 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]: ...
+
+LOGFIRE_PACKAGE_DIR: Incomplete
+
+def is_logfire_code(code: CodeType) -> bool: ...
 @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.4.0 → logfire_api-5.6.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.4.0 → logfire_api-5.6.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.4.0 → logfire_api-5.6.0}/logfire_api/_internal/json_encoder.pyi

@@ -12,6 +12,11 @@ EncoderFunction: Incomplete
 
 @cache
 def encoder_by_type() -> dict[type[Any], EncoderFunction]: ...
+def numpy_scalar_to_python(o: Any) -> Any:
+    """Convert a NumPy bool, integer or floating scalar to the equivalent Python value, and return anything else as is.
+
+    Without this, a value like `numpy.int64(42)` (e.g. from `df['col'].sum()`) would be recorded as its repr.
+    """
 def to_json_value(o: Any, seen: set[int]) -> JsonValue: ...
 def logfire_json_dumps(obj: Any) -> str: ...
 def is_sqlalchemy(obj: Any) -> bool: ...

{logfire_api-5.4.0 → logfire_api-5.6.0}/logfire_api/_internal/main.pyi

@@ -19,7 +19,7 @@ from ..version import VERSION as VERSION
 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
@@ -30,11 +30,11 @@ from .integrations.mysql import MySQLConnection as MySQLConnection
 from .integrations.psycopg import Psycopg2Connection as Psycopg2Connection, PsycopgConnection as PsycopgConnection
 from .integrations.sqlite3 import SQLite3Connection as SQLite3Connection
 from .integrations.system_metrics import Base as SystemMetricsBase, Config as SystemMetricsConfig
-from .json_encoder import logfire_json_dumps as logfire_json_dumps
+from .json_encoder import logfire_json_dumps as logfire_json_dumps, numpy_scalar_to_python as numpy_scalar_to_python
 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
@@ -51,7 +51,7 @@ from opentelemetry.sdk.trace import ReadableSpan, Span
 from opentelemetry.trace import SpanContext, SpanKind
 from opentelemetry.util import types as otel_types
 from pydantic_evals.reporting import EvaluationReport
-from pydantic_monty import AsyncMontyWebsocket
+from pydantic_monty import AsyncMontyRemote
 from pymongo.monitoring import CommandFailedEvent as CommandFailedEvent, CommandStartedEvent as CommandStartedEvent, CommandSucceededEvent as CommandSucceededEvent
 from snowflake.connector.connection import SnowflakeConnection
 from sqlalchemy import Engine
@@ -527,13 +527,13 @@ 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 = ..., 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) -> AsyncMontyWebsocket:
+    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) -> AsyncMontyRemote:
         """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 [`pydantic_monty.AsyncMontyWebsocket`][pydantic_monty.AsyncMontyWebsocket] pool;
-        use it as an async context manager and check out sessions from it:
+        Returns a [`pydantic_monty.AsyncMontyRemote`][pydantic_monty.AsyncMontyRemote] pool that
+        authenticates with your Logfire API key. Use it as an async context manager and check out sessions from it:
 
         ```py
         import logfire
@@ -549,6 +549,17 @@ class Logfire:
 
         No connection is made until a session is checked out.
 
+        Because the pool is a plain `AsyncMontyRemote`, you can pass this method wherever a Monty pool
+        factory is expected, for example `CodeMode(monty_sandbox=logfire.agent_sandboxes)` in Pydantic AI.
+
+        Checkout errors from the sandboxes server are Monty's own exceptions; this method does not wrap them.
+        An exception raised by your `metadata` callback propagates unchanged. A refused checkout raises
+        `MontyRefusedError`. For `UNAUTHENTICATED` or
+        `PERMISSION_DENIED`, check that the key is a project API key with the
+        `project:execute_agent_sandboxes` scope, that its region matches the server URL, and that Agent
+        Sandboxes are enabled for the project. For `RESOURCE_EXHAUSTED`, lower `max_processes` or retry
+        after a delay.
+
         The Logfire platform records sandbox usage itself. The current trace context is sent
         with each session so those spans join the caller's trace.
 
@@ -556,27 +567,32 @@ class Logfire:
         The defaults described below are the currently assumed defaults and may change in future versions.
 
         Args:
-            api_key: A Logfire API key with the `project:execute_agent_sandboxes` scope.
+            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 WebSocket URL of the sandboxes server.
-                Defaults to the Logfire region the API key belongs to.
-            max_processes: Cap on concurrent sandbox connections. Defaults to `None`, which uses
+            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
-                connection closed and the call raises `MontyCrashedError`. `None` waits indefinitely.
+                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.
-            connect_headers: Called once per session to produce extra headers for the WebSocket
-                connection. These are merged with the `Authorization` header and win on conflicts.
+            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 `AsyncMontyWebsocket` for future compatibility.
+            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.

{logfire_api-5.4.0 → logfire_api-5.6.0}/logfire_api/_internal/scrubbing.pyi

@@ -1,6 +1,7 @@
 import re
 import typing_extensions
 from .constants import ATTRIBUTES_CONFIG as ATTRIBUTES_CONFIG, ATTRIBUTES_JSON_SCHEMA_KEY as ATTRIBUTES_JSON_SCHEMA_KEY, ATTRIBUTES_LOGGING_NAME as ATTRIBUTES_LOGGING_NAME, ATTRIBUTES_LOG_LEVEL_NAME_KEY as ATTRIBUTES_LOG_LEVEL_NAME_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_PACKAGE_VERSIONS as ATTRIBUTES_PACKAGE_VERSIONS, ATTRIBUTES_PENDING_SPAN_REAL_PARENT_KEY as ATTRIBUTES_PENDING_SPAN_REAL_PARENT_KEY, ATTRIBUTES_SAMPLE_RATE_KEY as ATTRIBUTES_SAMPLE_RATE_KEY, ATTRIBUTES_SCRUBBED_KEY as ATTRIBUTES_SCRUBBED_KEY, ATTRIBUTES_SPAN_TYPE_KEY as ATTRIBUTES_SPAN_TYPE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY, MESSAGE_FORMATTED_VALUE_LENGTH_LIMIT as MESSAGE_FORMATTED_VALUE_LENGTH_LIMIT, RESOURCE_ATTRIBUTES_VERSION as RESOURCE_ATTRIBUTES_VERSION
+from .json_encoder import logfire_json_dumps as logfire_json_dumps
 from .stack_info import STACK_INFO_KEYS as STACK_INFO_KEYS
 from .utils import ReadableSpanDict as ReadableSpanDict, truncate_string as truncate_string
 from _typeshed import Incomplete
@@ -62,7 +63,7 @@ class SpanScrubber:
     and hold and mutate state about the span being scrubbed, specifically the scrubbed notes.
     """
     scrubbed: list[ScrubbedNote]
-    did_scrub: bool
+    scrub_count: int
     def __init__(self, parent: Scrubber) -> None: ...
     def scrub_span(self, span: ReadableSpanDict): ...
     def scrub_log(self, log: LogRecord) -> LogRecord: ...

logfire_api-5.6.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.4.0 → logfire_api-5.6.0}/logfire_api/integrations/logging.pyi

@@ -2,7 +2,6 @@ from .. import Logfire as Logfire
 from .._internal.constants import ATTRIBUTES_LOGGING_ARGS_KEY as ATTRIBUTES_LOGGING_ARGS_KEY, ATTRIBUTES_LOGGING_NAME as ATTRIBUTES_LOGGING_NAME, ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_MESSAGE_TEMPLATE_KEY as ATTRIBUTES_MESSAGE_TEMPLATE_KEY, ATTRIBUTES_TAGS_KEY as ATTRIBUTES_TAGS_KEY, LOGGING_TO_OTEL_LEVEL_NUMBERS as LOGGING_TO_OTEL_LEVEL_NUMBERS
 from .._internal.utils import is_instrumentation_suppressed as is_instrumentation_suppressed
 from _typeshed import Incomplete
-from collections.abc import Mapping as Mapping
 from logging import Handler as LoggingHandler, LogRecord
 from typing import Any, ClassVar
 
@@ -15,11 +14,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.4.0 → logfire_api-5.6.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.4.0 → logfire_api-5.6.0}/logfire_api/sampling/_tail_sampling.pyi

@@ -77,9 +77,10 @@ class TailSamplingProcessor(WrapperSpanProcessor):
     """
     get_tail_sample_rate: Incomplete
     deferred_processor: Incomplete
+    prepare_ended_span: Incomplete
     traces: dict[int, TraceBuffer]
     lock: Incomplete
-    def __init__(self, processor: SpanProcessor, get_tail_sample_rate: Callable[[TailSamplingSpanInfo], float], deferred_processor: SpanProcessor | None = None) -> None: ...
+    def __init__(self, processor: SpanProcessor, get_tail_sample_rate: Callable[[TailSamplingSpanInfo], float], deferred_processor: SpanProcessor | None = None, *, prepare_ended_span: Callable[[ReadableSpan], ReadableSpan] | None = None) -> None: ...
     def on_start(self, span: Span, parent_context: context.Context | None = None) -> None: ...
     def on_end(self, span: ReadableSpan) -> None: ...
     def check_span(self, span_info: TailSamplingSpanInfo) -> bool:

{logfire_api-5.4.0 → logfire_api-5.6.0}/logfire_api/types.pyi

@@ -18,6 +18,9 @@ class SpanLevel:
     `<`, `>`, `<=`, or `>=`, so e.g. `level >= 'error'` is valid.
 
     Will raise an exception if compared to a non-string or an invalid level name.
+
+    Hashing a level warns and uses its name, so `level in {'warn', 'error'}` works,
+    but `level in {13}` does not. Prefer `level.name in {...}`.
     """
     number: int
     @classmethod

{logfire_api-5.4.0 → logfire_api-5.6.0}/pyproject.toml

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

logfire_api-5.4.0/logfire_api/_internal/agent_sandboxes.pyi

@@ -1,10 +0,0 @@
-from collections.abc import Callable, Mapping as Mapping
-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 AsyncMontyWebsocket
-from typing import Any
-
-def agent_sandboxes_url(base_url: str) -> str:
-    """Convert a Logfire HTTP(S) base URL into the agent sandboxes WebSocket URL."""
-def create_agent_sandboxes(logfire_instance: Logfire, *, api_key: str | None, url: str | None, connect_headers: Callable[[], Mapping[str, str]] | None = None, **kwargs: Any) -> AsyncMontyWebsocket: ...