logfire-api 5.1.0__tar.gz → 5.2.0__tar.gz

{logfire_api-5.1.0 → logfire_api-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: logfire-api
-Version: 5.1.0
+Version: 5.2.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.1.0 → logfire_api-5.2.0}/logfire_api/__init__.py

@@ -153,6 +153,8 @@ except ImportError:
 
             def instrument_pydantic_ai(self, *args, **kwargs) -> None: ...
 
+            def instrument_monty(self, *args, **kwargs) -> None: ...
+
             def instrument_pymongo(self, *args, **kwargs) -> None: ...
 
             def instrument_sqlalchemy(self, *args, **kwargs) -> None: ...
@@ -176,6 +178,8 @@ except ImportError:
 
             def instrument_surrealdb(self, *args, **kwargs) -> None: ...
 
+            def instrument_snowflake(self, *args, **kwargs) -> None: ...
+
             def instrument_requests(self, *args, **kwargs) -> None: ...
 
             def instrument_httpx(self, *args, **kwargs) -> None: ...
@@ -242,6 +246,7 @@ except ImportError:
         instrument_wsgi = DEFAULT_LOGFIRE_INSTANCE.instrument_wsgi
         instrument_pydantic = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic
         instrument_pydantic_ai = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic_ai
+        instrument_monty = DEFAULT_LOGFIRE_INSTANCE.instrument_monty
         instrument_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
         instrument_openai = DEFAULT_LOGFIRE_INSTANCE.instrument_openai
         instrument_openai_agents = DEFAULT_LOGFIRE_INSTANCE.instrument_openai_agents
@@ -255,6 +260,7 @@ except ImportError:
         instrument_httpx = DEFAULT_LOGFIRE_INSTANCE.instrument_httpx
         instrument_requests = DEFAULT_LOGFIRE_INSTANCE.instrument_requests
         instrument_surrealdb = DEFAULT_LOGFIRE_INSTANCE.instrument_surrealdb
+        instrument_snowflake = DEFAULT_LOGFIRE_INSTANCE.instrument_snowflake
         instrument_psycopg = DEFAULT_LOGFIRE_INSTANCE.instrument_psycopg
         instrument_django = DEFAULT_LOGFIRE_INSTANCE.instrument_django
         instrument_flask = DEFAULT_LOGFIRE_INSTANCE.instrument_flask

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/__init__.pyi

@@ -16,7 +16,7 @@ from logfire.propagate import attach_context as attach_context, get_context as g
 from logfire.sampling import SamplingOptions as SamplingOptions
 from typing import Any
 
-__all__ = ['Logfire', 'LogfireSpan', 'LevelName', 'AdvancedOptions', 'ConsoleOptions', 'CodeSource', 'PydanticPlugin', 'configure', 'span', 'instrument', 'log', 'trace', 'debug', 'notice', 'info', 'warn', 'warning', 'error', 'exception', 'fatal', 'force_flush', 'log_slow_async_callbacks', 'install_auto_tracing', 'instrument_asgi', 'instrument_wsgi', 'instrument_pydantic', 'instrument_pydantic_ai', 'instrument_fastapi', 'instrument_openai', 'instrument_openai_agents', 'instrument_anthropic', 'instrument_google_genai', 'instrument_litellm', 'instrument_dspy', 'instrument_print', 'instrument_asyncpg', 'instrument_httpx', 'instrument_celery', 'instrument_requests', 'instrument_psycopg', 'instrument_django', 'instrument_flask', 'instrument_starlette', 'instrument_litestar', 'instrument_aiohttp_client', 'instrument_aiohttp_server', 'instrument_sqlalchemy', 'instrument_sqlite3', 'instrument_aws_lambda', 'instrument_redis', 'instrument_pymongo', 'instrument_mysql', 'instrument_surrealdb', 'instrument_system_metrics', 'instrument_mcp', 'instrument_claude_agent_sdk', 'AutoTraceModule', 'with_tags', 'with_settings', 'suppress_scopes', 'shutdown', 'no_auto_trace', 'ScrubMatch', 'ScrubbingOptions', 'VERSION', 'add_non_user_code_prefix', 'suppress_instrumentation', 'StructlogProcessor', 'LogfireLoggingHandler', 'loguru_handler', 'SamplingOptions', 'MetricsOptions', 'VariablesOptions', 'LocalVariablesOptions', 'variables', 'var', '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', '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
@@ -26,6 +26,7 @@ log_slow_async_callbacks = DEFAULT_LOGFIRE_INSTANCE.log_slow_async_callbacks
 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
 instrument_asgi = DEFAULT_LOGFIRE_INSTANCE.instrument_asgi
 instrument_wsgi = DEFAULT_LOGFIRE_INSTANCE.instrument_wsgi
 instrument_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
@@ -54,6 +55,7 @@ instrument_redis = DEFAULT_LOGFIRE_INSTANCE.instrument_redis
 instrument_pymongo = DEFAULT_LOGFIRE_INSTANCE.instrument_pymongo
 instrument_mysql = DEFAULT_LOGFIRE_INSTANCE.instrument_mysql
 instrument_surrealdb = DEFAULT_LOGFIRE_INSTANCE.instrument_surrealdb
+instrument_snowflake = DEFAULT_LOGFIRE_INSTANCE.instrument_snowflake
 instrument_system_metrics = DEFAULT_LOGFIRE_INSTANCE.instrument_system_metrics
 instrument_mcp = DEFAULT_LOGFIRE_INSTANCE.instrument_mcp
 instrument_claude_agent_sdk = DEFAULT_LOGFIRE_INSTANCE.instrument_claude_agent_sdk

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/_internal/cli/run.pyi

@@ -1,6 +1,6 @@
 import argparse
 from _typeshed import Incomplete
-from collections.abc import Collection, Generator, Mapping
+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
@@ -34,6 +34,13 @@ class InstrumentationContext:
     recommendations: set[InstrumentationRecommendation]
 
 def parse_run(args: argparse.Namespace) -> None: ...
+def load_console_entry_point(name: str) -> Callable[[], object] | None:
+    """Load one installed `console_scripts` entry point before local modules can shadow it."""
+@contextmanager
+def without_working_directory_on_sys_path() -> Generator[None, None, None]:
+    """Temporarily give entry-point imports the path behavior of an installed launcher."""
+def run_console_entry_point(entry_point: Callable[[], object], argv: list[str]) -> None:
+    """Run a loaded console entry point with the target command's arguments."""
 @contextmanager
 def alter_sys_argv(argv: list[str], cmd: str) -> Generator[None, None, None]: ...
 def is_uv_installed() -> bool:

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/_internal/client.pyi

@@ -1,5 +1,6 @@
 from .auth import UserToken as UserToken, UserTokenCollection as UserTokenCollection
 from .constants import HTTP_CONNECT_TIMEOUT as HTTP_CONNECT_TIMEOUT
+from .http_transport import install_connection_policy as install_connection_policy
 from .server_response import ServerResponseCallback as ServerResponseCallback, install_logfire_response_hook as install_logfire_response_hook
 from .utils import UnexpectedResponse as UnexpectedResponse
 from _typeshed import Incomplete

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/_internal/config.pyi

@@ -4,17 +4,18 @@ import requests
 from ..propagate import NoExtractTraceContextPropagator as NoExtractTraceContextPropagator, WarnOnExtractTraceContextPropagator as WarnOnExtractTraceContextPropagator
 from ..types import ExceptionCallback as ExceptionCallback
 from .client import InvalidProjectName as InvalidProjectName, LogfireClient as LogfireClient, ProjectAlreadyExists as ProjectAlreadyExists
-from .config_params import ParamManager as ParamManager, PydanticPluginRecordValues as PydanticPluginRecordValues, normalize_token as normalize_token
+from .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.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
+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.quiet_metrics import QuietMetricExporter as QuietMetricExporter
 from .exporters.remove_pending import RemovePendingSpansExporter as RemovePendingSpansExporter
 from .exporters.test import TestExporter as TestExporter
 from .forwarding import OTLPForwardingManager as OTLPForwardingManager
+from .http_transport import install_connection_policy as install_connection_policy
 from .integrations.executors import instrument_executors as instrument_executors
 from .interactive import ask_or_default as ask_or_default, ask_required as ask_required, require_answer as require_answer
 from .logs import ProxyLoggerProvider as ProxyLoggerProvider
@@ -65,6 +66,7 @@ class ConsoleOptions:
     min_log_level: LevelName = ...
     show_project_link: bool = ...
     output: TextIO | None = ...
+    include_attributes: bool | None = ...
 
 @dataclass
 class AdvancedOptions:
@@ -77,6 +79,7 @@ class AdvancedOptions:
     emit_configuration_span: bool | None = ...
     server_response_hook: ServerResponseCallback | None = ...
     resource_detectors: Sequence[ResourceDetector | str] | None = ...
+    compression: CompressionValues | None = ...
     def generate_base_url(self, token: str, warn_unknown_region: bool = True) -> str:
         """Resolve the base API URL for `token`, honouring an explicitly configured `base_url`.
 

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/_internal/config_params.pyi

@@ -12,6 +12,7 @@ from typing import Any, TypeVar
 
 T = TypeVar('T')
 PydanticPluginRecordValues: Incomplete
+CompressionValues: Incomplete
 
 @dataclass(slots=True)
 class ConfigParam:
@@ -45,6 +46,7 @@ CONSOLE_SPAN_STYLE: Incomplete
 CONSOLE_INCLUDE_TIMESTAMP: Incomplete
 CONSOLE_INCLUDE_TAGS: Incomplete
 CONSOLE_VERBOSE: Incomplete
+CONSOLE_INCLUDE_ATTRIBUTES: Incomplete
 CONSOLE_MIN_LOG_LEVEL: Incomplete
 CONSOLE_SHOW_PROJECT_LINK: Incomplete
 PYDANTIC_PLUGIN_RECORD: Incomplete
@@ -56,6 +58,7 @@ IGNORE_NO_CONFIG: Incomplete
 BASE_URL: Incomplete
 DISTRIBUTED_TRACING: Incomplete
 EMIT_CONFIGURATION_SPAN: Incomplete
+COMPRESSION: Incomplete
 HTTPX_CAPTURE_ALL: Incomplete
 AIOHTTP_CLIENT_CAPTURE_ALL: Incomplete
 CONFIG_PARAMS: Incomplete

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/_internal/exporters/console.pyi

@@ -35,7 +35,7 @@ class SimpleConsoleSpanExporter(SpanExporter):
     This simple version does not indent spans based on their parent(s), instead spans are printed as a
     flat list.
     """
-    def __init__(self, output: TextIO | None = None, colors: ConsoleColorsValues = 'auto', include_timestamp: bool = True, include_tags: bool = True, verbose: bool = False, min_log_level: LevelName = 'info') -> None: ...
+    def __init__(self, output: TextIO | None = None, colors: ConsoleColorsValues = 'auto', include_timestamp: bool = True, include_tags: bool = True, verbose: bool = False, min_log_level: LevelName = 'info', include_attributes: bool | None = None) -> None: ...
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         """Export the spans to the console."""
     def export_record(self, span: Record) -> None:
@@ -52,7 +52,7 @@ class IndentedConsoleSpanExporter(SimpleConsoleSpanExporter):
     Spans are intended based simply on how many parents they have. This will work well when spans don't overlap,
     but will be hard to understand when multiple spans are in progress at the same time.
     """
-    def __init__(self, output: TextIO | None = None, colors: ConsoleColorsValues = 'auto', include_timestamp: bool = True, include_tags: bool = True, verbose: bool = False, min_log_level: LevelName = 'info') -> None: ...
+    def __init__(self, output: TextIO | None = None, colors: ConsoleColorsValues = 'auto', include_timestamp: bool = True, include_tags: bool = True, verbose: bool = False, min_log_level: LevelName = 'info', include_attributes: bool | None = None) -> None: ...
     def export_record(self, span: Record) -> None:
         """Get the span indent based on `self._indent_level`, then print the span with that indent."""
 
@@ -63,7 +63,7 @@ class ShowParentsConsoleSpanExporter(SimpleConsoleSpanExporter):
     the previously displayed span is not the parent or sibling of a span, parents are printed (with "dim" color)
     so it\'s easy (or as easy as possible in a terminal) to understand how nested spans are related.
     '''
-    def __init__(self, output: TextIO | None = None, colors: ConsoleColorsValues = 'auto', include_timestamp: bool = True, include_tags: bool = True, verbose: bool = False, min_log_level: LevelName = 'info') -> None: ...
+    def __init__(self, output: TextIO | None = None, colors: ConsoleColorsValues = 'auto', include_timestamp: bool = True, include_tags: bool = True, verbose: bool = False, min_log_level: LevelName = 'info', include_attributes: bool | None = None) -> None: ...
     def export_record(self, span: Record) -> None:
         """Print any parent spans which aren't in the current stack of displayed spans, then print this span."""
 

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/_internal/exporters/otlp.pyi

@@ -1,6 +1,8 @@
 import atexit
+import logging
 import requests
 from ..constants import ATTRIBUTES_MESSAGE_KEY as ATTRIBUTES_MESSAGE_KEY, ATTRIBUTES_SPAN_TYPE_KEY as ATTRIBUTES_SPAN_TYPE_KEY, HTTP_CONNECT_TIMEOUT as HTTP_CONNECT_TIMEOUT, OTLP_MAX_INT_SIZE as OTLP_MAX_INT_SIZE, log_level_attributes as log_level_attributes
+from ..http_transport import install_connection_policy as install_connection_policy
 from ..stack_info import STACK_INFO_KEYS as STACK_INFO_KEYS
 from ..utils import logger as logger, platform_is_emscripten as platform_is_emscripten, truncate_string as truncate_string
 from .wrapper import WrapperLogExporter as WrapperLogExporter, WrapperSpanExporter as WrapperSpanExporter
@@ -16,18 +18,46 @@ from opentelemetry.sdk.trace.export import SpanExportResult
 from pathlib import Path
 from requests import Session
 from threading import Thread
-from typing import Any
+from typing import Any, Protocol
+from typing_extensions import Buffer
+
+class _OTLPExportResult(Protocol):
+    success: bool
+    status_code: int | None
+    error: Exception | None
+
+class _OTLPClient(Protocol):
+    def export(self, data: bytes) -> _OTLPExportResult: ...
+    def shutdown(self) -> None: ...
+
+class _QuietConnectionErrorLogger(logging.LoggerAdapter):
+    def error(self, msg: object, *args: Any, **kwargs: Any) -> None: ...
+
+class _BodySizeCheckingOTLPClient:
+    client: Incomplete
+    exporter: Incomplete
+    def __init__(self, client: _OTLPClient, exporter: BodySizeCheckingOTLPSpanExporter) -> None: ...
+    def export(self, data: bytes) -> _OTLPExportResult: ...
+    def shutdown(self) -> None: ...
+
+class ZstdCompressFn(Protocol):
+    """Signature of `compression.zstd.compress` and `backports.zstd.compress`."""
+    def __call__(self, data: Buffer, level: int | None = None, options: Mapping[int, int] | None = None, zstd_dict: Any = None) -> bytes: ...
+
+zstd_compress: ZstdCompressFn | None
 
 @atexit.register
 def cleanup_disk_retryers() -> None: ...
 
 class BodySizeCheckingOTLPSpanExporter(OTLPSpanExporter):
     max_body_size: Incomplete
+    current_num_spans: int
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
     def export(self, spans: Sequence[ReadableSpan]): ...
 
 class OTLPExporterHttpSession(Session):
     """A requests.Session subclass that defers failed requests to a DiskRetryer."""
+    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

logfire_api-5.2.0/logfire_api/_internal/http_transport.pyi

@@ -0,0 +1,47 @@
+from requests import Session
+from requests.adapters import HTTPAdapter
+from typing import Any
+from urllib3.connectionpool import HTTPConnectionPool
+
+IDLE_CONNECTION_RECYCLE_SECONDS: int
+TCP_KEEPALIVE_IDLE_SECONDS: int
+TCP_KEEPALIVE_INTERVAL_SECONDS: int
+TCP_KEEPALIVE_FAILED_PROBES: int
+
+def keepalive_socket_options() -> list[tuple[int, int, int | bytes]]:
+    """`urllib3`'s default socket options plus TCP keepalive.
+
+    Building on `HTTPConnection.default_socket_options` keeps `TCP_NODELAY`, which `urllib3` sets
+    and which we have no reason to drop. The class is read off the module at call time because
+    `urllib3` swaps it out under Pyodide, for an Emscripten connection that talks over `fetch()`
+    and so has neither a socket nor any default options.
+    """
+
+class _IdleRecyclingPoolMixin(HTTPConnectionPool):
+    """Closes a pooled connection that has sat idle longer than the recycle window.
+
+    The unit that goes stale is one connection, not the session: a session can be busy
+    continuously while an individual pooled connection sits unused. That is the normal shape for
+    Logfire, where one session carries traces, metrics and logs from different threads, so a
+    steady trace stream keeps the session active while the connection that last served a metric
+    export waits out the full export interval.
+
+    `urllib3` pools from a LIFO queue, which makes this sharper than steady-state staleness.
+    Sequential traffic reuses the connection on top of the stack, so a connection opened during
+    a brief overlap is used once and then left at the bottom, idle for as long as the workload
+    stays sequential. It is handed back out at the next overlap, which is exactly when a request
+    is least able to tolerate a dead socket. Recycling on the way out of the pool is what catches
+    that connection before it is used.
+
+    `urllib3` already drops a pooled connection it can see was closed. This extends that to the
+    case it cannot see, closing on the way out of the pool and letting `urllib3` reconnect
+    lazily, exactly as it does for a connection it detected as dropped.
+    """
+
+class LogfireHTTPAdapter(HTTPAdapter):
+    """A `requests` adapter that enables TCP keepalive and recycles idle pooled connections."""
+    def init_poolmanager(self, connections: int, maxsize: int, block: bool = ..., **pool_kwargs: Any) -> None: ...
+    def proxy_manager_for(self, proxy: str, **proxy_kwargs: Any) -> Any: ...
+
+def install_connection_policy(session: Session) -> None:
+    """Apply the keepalive and idle recycle policy to a session Logfire owns."""

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/_internal/integrations/mcp.pyi

@@ -1,7 +1,12 @@
+from collections.abc import Awaitable as Awaitable, Callable
 from logfire import LevelName as LevelName, Logfire as Logfire
 from logfire._internal.utils import handle_internal_errors as handle_internal_errors
 from logfire.propagate import attach_context as attach_context, get_context as get_context
-from mcp.shared.session import ReceiveRequestT as ReceiveRequestT
-from mcp.types import ClientRequest as ClientRequest, ClientResult as ClientResult, ServerRequest as ServerRequest, ServerResult as ServerResult
+from typing import Any, Protocol
+
+class _RequestResponder(Protocol):
+    """The MCP 1 responder interface used by instrumentation."""
+    request: Any
+    respond: Callable[..., Awaitable[None]]
 
 def instrument_mcp(logfire_instance: Logfire, propagate_otel_context: bool): ...

logfire_api-5.2.0/logfire_api/_internal/integrations/monty.pyi

@@ -0,0 +1,29 @@
+from _typeshed import Incomplete
+from collections.abc import Sequence
+from logfire import Logfire as Logfire
+from logfire._internal.constants import 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_TAGS_KEY as ATTRIBUTES_TAGS_KEY, DISABLE_CONSOLE_KEY as DISABLE_CONSOLE_KEY
+from logfire._internal.formatter import logfire_format as logfire_format
+from logfire.version import VERSION as VERSION
+from opentelemetry._logs import LogRecord, Logger, SeverityNumber
+from opentelemetry.context import Context
+from opentelemetry.trace import Link as Link, Span, SpanKind, Tracer
+from opentelemetry.util import types as otel_types
+from typing import Any
+
+def instrument_monty(logfire_instance: Logfire) -> None:
+    """Install process-wide Monty instrumentation using Logfire's OpenTelemetry components."""
+
+class LogfireMontyTracer(Tracer):
+    """Standard OTel tracer adding settings from a specific Logfire instance."""
+    logfire: Incomplete
+    def __init__(self, logfire_instance: Logfire) -> None: ...
+    def start_span(self, name: str, context: Context | None = None, kind: SpanKind = ..., attributes: otel_types.Attributes = None, links: Sequence[Link] | None = None, start_time: int | None = None, record_exception: bool = True, set_status_on_exception: bool = True) -> Span: ...
+    start_as_current_span: Incomplete
+
+class LogfireMontyLogger(Logger):
+    """Standard OTel logger adding settings from a specific Logfire instance."""
+    logger: Incomplete
+    logfire: Incomplete
+    def __init__(self, logger: Logger, logfire_instance: Logfire) -> None: ...
+    def enabled(self, *, context: Context | None = None, severity_number: SeverityNumber | None = None, event_name: str | None = None) -> bool: ...
+    def emit(self, record: LogRecord | None = None, **kwargs: Any) -> None: ...

logfire_api-5.2.0/logfire_api/_internal/integrations/snowflake.pyi

@@ -0,0 +1,7 @@
+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 snowflake.connector.connection import SnowflakeConnection
+from types import ModuleType
+
+def instrument_snowflake(logfire_instance: Logfire, conn_or_module: ModuleType | SnowflakeConnection | None, capture_parameters: bool) -> None: ...

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/_internal/logs.pyi

@@ -1,8 +1,9 @@
 import dataclasses
 from dataclasses import dataclass
 from logfire._internal.constants import LEVEL_NUMBERS as LEVEL_NUMBERS
-from opentelemetry._logs import LogRecord, Logger, LoggerProvider
-from opentelemetry.util.types import _ExtendedAttributes
+from opentelemetry._logs import LogRecord, Logger, LoggerProvider, SeverityNumber
+from opentelemetry.context import Context
+from opentelemetry.util.types import Attributes
 from threading import RLock
 from typing import Any, overload
 from weakref import WeakSet
@@ -15,7 +16,7 @@ class ProxyLoggerProvider(LoggerProvider):
     lock: RLock = dataclasses.field(default_factory=RLock)
     suppressed_scopes: set[str] = dataclasses.field(default_factory=set[str])
     min_level: int = ...
-    def get_logger(self, name: str, version: str | None = None, schema_url: str | None = None, attributes: _ExtendedAttributes | None = None) -> Logger: ...
+    def get_logger(self, name: str, version: str | None = None, schema_url: str | None = None, attributes: Attributes | None = None) -> Logger: ...
     def set_min_level(self, min_level: int) -> None: ...
     def suppress_scopes(self, *scopes: str) -> None: ...
     def set_provider(self, logger_provider: LoggerProvider) -> None: ...
@@ -28,10 +29,11 @@ class ProxyLogger(Logger):
     name: str
     version: str | None = ...
     schema_url: str | None = ...
-    attributes: _ExtendedAttributes | None = ...
+    attributes: Attributes | None = ...
     @overload
     def emit(self, record: LogRecord) -> None: ...
     @overload
     def emit(self, **kwargs: Any) -> None: ...
     def set_logger(self, provider: LoggerProvider) -> None: ...
+    def enabled(self, *, context: Context | None = None, severity_number: SeverityNumber | None = None, event_name: str | None = None) -> bool: ...
     def __getattr__(self, item: str): ...

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/_internal/main.pyi

@@ -51,6 +51,7 @@ from opentelemetry.trace import SpanContext, SpanKind
 from opentelemetry.util import types as otel_types
 from pydantic_evals.reporting import EvaluationReport
 from pymongo.monitoring import CommandFailedEvent as CommandFailedEvent, CommandStartedEvent as CommandStartedEvent, CommandSucceededEvent as CommandSucceededEvent
+from snowflake.connector.connection import SnowflakeConnection
 from sqlalchemy import Engine
 from sqlalchemy.ext.asyncio import AsyncEngine
 from starlette.applications import Starlette
@@ -440,16 +441,37 @@ class Logfire:
                 Pass a connection class to instrument all instances of that class.
                 By default, all connection classes are instrumented.
         """
+    def instrument_snowflake(self, conn_or_module: ModuleType | SnowflakeConnection | None = None, *, capture_parameters: bool = False) -> None:
+        """Instrument the [Snowflake Connector for Python](https://docs.snowflake.com/en/developer-guide/python-connector/python-connector) so that a span is created for each query.
+
+        Calls to `execute_async()` create a `snowflake execute async` span that measures query submission,
+        not server-side execution.
+
+        Args:
+            conn_or_module: Pass a single connection instance to instrument only that connection.
+                By default (`None`), all connections are instrumented, including ones created later.
+            capture_parameters: Set to `True` to capture query parameters as span attributes.
+                Be cautious when enabling this, as it may lead to sensitive data being captured in traces.
+                Instrumenting the same target again has no effect; the first call determines this setting,
+                and a later call with a different value emits a warning.
+                A connection keeps the setting it was instrumented with, even if the module is instrumented later.
+        """
     def instrument_mcp(self, *, propagate_otel_context: bool = True) -> None:
         """Instrument the [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk).
 
         Instruments both the client and server side. If possible, calling this in both the client and server
         processes is recommended for nice distributed traces.
 
+        This is only needed with mcp 1.x. Version 2 of the SDK (which fastmcp 4 depends on) emits
+        OpenTelemetry spans and propagates the trace context via `_meta` by itself, so with it
+        `logfire.configure()` is all that's needed. Calling this method there does nothing
+        except emit a `UserWarning` saying so.
+
         Args:
             propagate_otel_context: Whether to enable propagation of the OpenTelemetry context
                 for distributed tracing.
                 Set to False to prevent setting extra fields like `traceparent` on the metadata of requests.
+                Ignored with mcp 2, which always propagates the context.
         """
     def instrument_claude_agent_sdk(self) -> AbstractContextManager[None]:
         """Instrument the [Claude Agent SDK](https://platform.claude.com/docs/en/agent-sdk/overview).
@@ -488,6 +510,16 @@ class Logfire:
     def instrument_pydantic_ai(self, obj: pydantic_ai.Agent | None = None, /, *, include_binary_content: bool | None = None, include_content: bool | None = None, version: Literal[1, 2, 3, 4, 5] | None = None, event_mode: Literal['attributes', 'logs'] | None = None, **kwargs: Any) -> None: ...
     @overload
     def instrument_pydantic_ai(self, obj: pydantic_ai.models.Model, /, *, include_binary_content: bool | None = None, include_content: bool | None = None, version: Literal[1, 2, 3, 4, 5] | None = None, event_mode: Literal['attributes', 'logs'] | None = None, **kwargs: Any) -> pydantic_ai.models.Model: ...
+    def instrument_monty(self) -> None:
+        """Instrument Pydantic Monty.
+
+        Call this once after [`configure()`][logfire.configure] and before creating a Monty pool.
+        The first call selects the Logfire instance and its settings for the whole process;
+        subsequent calls do not replace them.
+
+        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 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.
 
@@ -1517,7 +1549,6 @@ class FastLogfireSpan:
 
 class LogfireSpan(ReadableSpan):
     def __init__(self, span_name: str, otlp_attributes: dict[str, otel_types.AttributeValue], tracer: _ProxyTracer, json_schema_properties: JsonSchemaProperties, links: Sequence[tuple[SpanContext, otel_types.Attributes]], span_kind: SpanKind = ...) -> None: ...
-    def __getattr__(self, name: str) -> Any: ...
     def __enter__(self) -> LogfireSpan: ...
     @handle_internal_errors
     def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: Any) -> None: ...
@@ -1568,7 +1599,7 @@ class NoopSpan:
 
     TODO this should also be used when tracing is disabled, e.g. before `logfire.configure()` has been called.
     """
-    def __init__(self, /, *_args: Any, **__kwargs: Any) -> None: ...
+    def __init__(self, *_args: Any, **__kwargs: Any) -> None: ...
     def __getattr__(self, _name: str) -> Any: ...
     def __enter__(self) -> NoopSpan: ...
     def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: Any) -> None: ...

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/_internal/metrics.pyi

@@ -2,6 +2,7 @@ import dataclasses
 from .utils import handle_internal_errors as handle_internal_errors
 from abc import ABC
 from collections.abc import Sequence
+from opentelemetry.context import Context
 from opentelemetry.metrics import CallbackT as CallbackT, Counter, Histogram, Instrument, Meter, MeterProvider, ObservableCounter, ObservableGauge, ObservableUpDownCounter, UpDownCounter, _Gauge as Gauge
 from opentelemetry.util.types import Attributes
 from threading import Lock
@@ -43,10 +44,10 @@ class _ProxyInstrument(ABC, Generic[InstrumentT]):
         """Called when a real meter is set on the creating _ProxyMeter."""
 
 class _ProxyCounter(_ProxyInstrument[Counter], Counter):
-    def add(self, amount: int | float, attributes: Attributes | None = None, *args: Any, **kwargs: Any) -> None: ...
+    def add(self, amount: int | float, attributes: Attributes | None = None, context: Context | None = None, *args: Any, **kwargs: Any) -> None: ...
 
 class _ProxyHistogram(_ProxyInstrument[Histogram], Histogram):
-    def record(self, amount: int | float, attributes: Attributes | None = None, *args: Any, **kwargs: Any) -> None: ...
+    def record(self, amount: int | float, attributes: Attributes | None = None, context: Context | None = None, *args: Any, **kwargs: Any) -> None: ...
 
 class _ProxyObservableCounter(_ProxyInstrument[ObservableCounter], ObservableCounter): ...
 class _ProxyObservableGauge(_ProxyInstrument[ObservableGauge], ObservableGauge): ...

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/_internal/tracer.pyi

@@ -1,7 +1,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_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 .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, sha256_string as sha256_string
 from _typeshed import Incomplete
 from collections.abc import Callable, Mapping, Sequence
@@ -70,7 +70,6 @@ class _LogfireWrappedSpan(trace_api.Span, ReadableSpan):
     def record_exception(self, exception: BaseException, attributes: otel_types.Attributes = None, timestamp: int | None = None, escaped: bool = False) -> None: ...
     def increment_metric(self, name: str, attributes: Mapping[str, otel_types.AttributeValue], value: float) -> None: ...
     def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: Any) -> None: ...
-    def __getattr__(self, name: str) -> Any: ...
 
 def get_parent_span(span: ReadableSpan) -> _LogfireWrappedSpan | None: ...
 

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/_internal/utils.pyi

@@ -18,9 +18,6 @@ from types import TracebackType
 from typing import Any, ParamSpec, TypeVar, TypedDict
 
 _ = BaseExceptionGroup
-
-class BaseExceptionGroup(BaseException):
-    """Stub for BaseExceptionGroup for Python < 3.11."""
 SysExcInfo = tuple[type[BaseException], BaseException, TracebackType | None] | tuple[None, None, None]
 P = ParamSpec('P')
 T = TypeVar('T')

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/experimental/api_client.pyi

@@ -6,16 +6,12 @@ from httpx._client import BaseClient
 from logfire._internal.config import get_base_url_from_token as get_base_url_from_token
 from logfire._internal.stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
 from pydantic_evals import Case, Dataset
-from pydantic_evals.evaluators import Evaluator, ReportEvaluator
+from pydantic_evals.evaluators import Evaluator as Evaluator, ReportEvaluator as ReportEvaluator
 from types import TracebackType
 from typing import Any, Generic, Literal, overload
 from typing_extensions import NotRequired, Self, TypeForm, TypeVar, TypedDict
 from uuid import UUID
 
-Case = Any
-Dataset = Any
-Evaluator = Any
-ReportEvaluator = Any
 DEFAULT_TIMEOUT: Incomplete
 T = TypeVar('T', bound=BaseClient)
 InputsT = TypeVar('InputsT')

{logfire_api-5.1.0 → logfire_api-5.2.0}/logfire_api/query_client.pyi

@@ -7,16 +7,33 @@ from types import TracebackType
 from typing import Any, Generic, TypeVar, TypedDict
 from typing_extensions import Self
 
-__all__ = ['QueryExecutionError', 'QueryRequestError', 'InfoRequestError', 'UnexpectedResponseError', 'ReadTokenInfo', 'ColumnDetails', 'RowQueryResults', 'LogfireQueryClient', 'AsyncLogfireQueryClient']
+__all__ = ['QueryExecutionError', 'QueryRequestError', 'InfoRequestError', 'UnexpectedResponseError', 'QueryRateLimitedError', 'ReadTokenInfo', 'ColumnDetails', 'RowQueryResults', 'LogfireQueryClient', 'AsyncLogfireQueryClient']
 
-class QueryExecutionError(RuntimeError):
+class _ProblemDetailsMixin:
+    """Additional details about an error response.
+
+    The server sends an [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457) problem detail body when the client
+    asks for one. When the server sends a different body, `problem` is `None`, and the other attributes are
+    `None` unless the response has a `Retry-After` header.
+    """
+    problem: dict[str, Any] | None
+    problem_type: str | None
+    retryable: bool | None
+    retry_after: float | None
+
+class QueryExecutionError(_ProblemDetailsMixin, RuntimeError):
     """Raised when the query execution fails on the server."""
-class QueryRequestError(RuntimeError):
+class QueryRequestError(_ProblemDetailsMixin, RuntimeError):
     """Raised when the query request is invalid."""
 class InfoRequestError(RuntimeError):
     """Raised when the request for read token info fails because of unavailable information."""
-class UnexpectedResponseError(RuntimeError):
+class UnexpectedResponseError(_ProblemDetailsMixin, RuntimeError):
     """Raised when the API responds with an unexpected status code, such as a `5xx` server error."""
+class QueryRateLimitedError(UnexpectedResponseError):
+    """Raised when the API responds with status code `429` because the request was rate limited.
+
+    Use `retry_after` to find how long to wait before the next request.
+    """
 
 class ReadTokenInfo(TypedDict, total=False):
     """Information about the read token."""

{logfire_api-5.1.0 → logfire_api-5.2.0}/pyproject.toml

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