logfire-api 4.41.0__tar.gz → 5.0.0__tar.gz

{logfire_api-4.41.0 → logfire_api-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: logfire-api
-Version: 4.41.0
+Version: 5.0.0
 Summary: Shim for the Logfire SDK which does nothing unless Logfire is installed
 Author-email: Pydantic Team <engineering@pydantic.dev>, Samuel Colvin <samuel@pydantic.dev>, Hasan Ramezani <hasan@pydantic.dev>, Adrian Garcia Badaracco <adrian@pydantic.dev>, David Montague <david@pydantic.dev>, Marcelo Trylesinski <marcelo@pydantic.dev>, David Hewitt <david.hewitt@pydantic.dev>, Alex Hall <alex@pydantic.dev>
 License-Expression: MIT

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/__init__.py

@@ -124,7 +124,8 @@ except ImportError:
             def with_settings(self, *args, **kwargs) -> Logfire:
                 return self
 
-            def force_flush(self, *args, **kwargs) -> None: ...
+            def force_flush(self, *args, **kwargs) -> bool:
+                return True
 
             def log_slow_async_callbacks(self, *args, **kwargs) -> None:  # pragma: no cover
                 return nullcontext()

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/_internal/cli/__init__.pyi

@@ -7,6 +7,8 @@ __all__ = ['main', 'logfire_info']
 class SavedReadToken(NamedTuple):
     token: str
     base_url: str
+    organization: str
+    project_name: str
 
 def logfire_info() -> str:
     """Show versions of logfire, OS and related packages."""

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/_internal/config.pyi

@@ -16,7 +16,7 @@ from .exporters.remove_pending import RemovePendingSpansExporter as RemovePendin
 from .exporters.test import TestExporter as TestExporter
 from .forwarding import OTLPForwardingManager as OTLPForwardingManager
 from .integrations.executors import instrument_executors as instrument_executors
-from .interactive import require_answer as require_answer
+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
 from .main import Logfire as Logfire
 from .metrics import ProxyMeterProvider as ProxyMeterProvider
@@ -24,7 +24,7 @@ from .scrubbing import BaseScrubber as BaseScrubber, NOOP_SCRUBBER as NOOP_SCRUB
 from .server_response import ServerResponseCallback as ServerResponseCallback, install_logfire_response_hook as install_logfire_response_hook
 from .stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
 from .tracer import OPEN_SPANS as OPEN_SPANS, PendingSpanProcessor as PendingSpanProcessor, ProxyTracerProvider as ProxyTracerProvider
-from .utils import SeededRandomIdGenerator as SeededRandomIdGenerator, ensure_data_dir_exists as ensure_data_dir_exists, handle_internal_errors as handle_internal_errors, platform_is_emscripten as platform_is_emscripten, suppress_instrumentation as suppress_instrumentation
+from .utils import SeededRandomIdGenerator as SeededRandomIdGenerator, ensure_data_dir_exists as ensure_data_dir_exists, handle_internal_errors as handle_internal_errors, platform_is_aws_lambda as platform_is_aws_lambda, platform_is_emscripten as platform_is_emscripten, suppress_instrumentation as suppress_instrumentation
 from _typeshed import Incomplete
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, field
@@ -46,8 +46,8 @@ from opentelemetry.sdk.resources import ResourceDetector
 from opentelemetry.sdk.trace import SpanProcessor
 from opentelemetry.sdk.trace.id_generator import IdGenerator
 from pathlib import Path
-from typing import Any, ClassVar, Literal, TextIO, TypedDict
-from typing_extensions import Self, Unpack
+from typing import Any, ClassVar, Literal, TextIO
+from typing_extensions import Self
 
 CREDENTIALS_FILENAME: str
 COMMON_REQUEST_HEADERS: Incomplete
@@ -140,9 +140,7 @@ class LocalVariablesOptions:
     instrument: bool = ...
     template_mismatch_policy: TemplateMismatchPolicy = ...
 
-class DeprecatedKwargs(TypedDict): ...
-
-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, **deprecated_kwargs: Unpack[DeprecatedKwargs]) -> 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, advanced: AdvancedOptions | None = None) -> Logfire:
     """Configure the logfire SDK.
 
     Args:
@@ -270,13 +268,13 @@ class LogfireConfig(_LogfireConfigData):
     def initialize(self) -> None:
         """Configure internals to start exporting traces and metrics."""
     def force_flush(self, timeout_millis: int = 30000) -> bool:
-        """Force flush all spans and metrics.
+        """Force flush all telemetry and forwarding pipelines.
 
         Args:
             timeout_millis: The timeout in milliseconds.
 
         Returns:
-            Whether the flush of spans was successful.
+            Whether every component that reports a status flushed successfully.
         """
     def shutdown(self, timeout_millis: int = 30000, flush: bool = True) -> bool:
         """Shut down variables, forwarding, traces, logs, and metrics."""

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/_internal/exporters/otlp.pyi

@@ -1,15 +1,17 @@
 import atexit
 import requests
-from ..constants import HTTP_CONNECT_TIMEOUT as HTTP_CONNECT_TIMEOUT
-from ..utils import logger as logger, platform_is_emscripten as platform_is_emscripten
+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 ..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
 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
-from opentelemetry.sdk.trace import ReadableSpan as ReadableSpan
+from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExportResult
 from pathlib import Path
 from requests import Session
@@ -61,7 +63,7 @@ class RetryFewerSpansSpanExporter(WrapperSpanExporter):
 class BodyTooLargeError(Exception):
     size: Incomplete
     max_size: Incomplete
-    def __init__(self, size: int, max_size: int) -> None: ...
+    def __init__(self, size: int, max_size: int | None) -> None: ...
 
 class SuppressedConnectionError(Exception): ...
 

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/_internal/forwarding.pyi

@@ -4,14 +4,16 @@ from collections.abc import Callable as Callable, Mapping, Sequence
 from dataclasses import dataclass
 from enum import Enum
 from logfire._internal.exporters.otlp import OTLPExporterHttpSession as OTLPExporterHttpSession
+from logfire._internal.main import Logfire as Logfire
 from logfire._internal.server_response import install_logfire_response_hook as install_logfire_response_hook
 from logfire._internal.utils import suppress_instrumentation as suppress_instrumentation
-from logfire.experimental.forwarding import ForwardExportRequestResponse as ForwardExportRequestResponse
 from logfire.types import ServerResponseCallback as ServerResponseCallback
 from logfire.version import VERSION as VERSION
 from opentelemetry.proto.collector.logs.v1.logs_service_pb2 import ExportLogsServiceResponse
 from opentelemetry.proto.collector.metrics.v1.metrics_service_pb2 import ExportMetricsServiceResponse
 from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import ExportTraceServiceResponse
+from starlette.requests import Request
+from starlette.responses import Response
 from threading import Thread
 from typing import Literal
 
@@ -48,6 +50,13 @@ class ForwardingErrorResponse:
     status_code: int
     content: bytes
 
+@dataclass
+class ForwardExportRequestResponse:
+    """Response returned from a forwarded export request to Logfire."""
+    status_code: int
+    headers: Mapping[str, str]
+    content: bytes
+
 @dataclass(frozen=True)
 class ForwardingAdmissionResult:
     response: Literal['success', 'partial_success']
@@ -81,5 +90,15 @@ class OTLPForwardingManager:
 
 def parse_forwarding_content_type(content_type: str) -> ForwardingContentType | None: ...
 def build_forwarding_request(*, path: str, headers: Mapping[str, str], body: bytes, max_body_size: int = ...) -> ForwardingRequest | ForwardingErrorResponse: ...
+def forward_export_request(*, path: str, headers: Mapping[str, str], body: bytes, logfire_instance: Logfire | None = None, max_body_size: int = ...) -> ForwardExportRequestResponse:
+    """Forward an export request to the Logfire API.
+
+    See the Logfire.forward_export_request method for more details.
+    """
+async def logfire_proxy(request: Request, *, logfire_instance: Logfire | None = None, max_body_size: int = ...) -> Response:
+    """A Starlette/FastAPI handler to proxy requests to Logfire.
+
+    See the Logfire.forward_export_request_starlette method for more details.
+    """
 def build_success_response(request: ForwardingRequest) -> ForwardExportRequestResponse: ...
 def build_partial_success_response(request: ForwardingRequest, *, message: str) -> ForwardExportRequestResponse: ...

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/_internal/integrations/flask.pyi

@@ -1,5 +1,4 @@
 from flask.app import Flask
-from logfire._internal.stack_info import warn_at_user_stacklevel as warn_at_user_stacklevel
 from logfire._internal.utils import maybe_capture_server_headers as maybe_capture_server_headers
 from logfire.integrations.flask import CommenterOptions as CommenterOptions, RequestHook as RequestHook, ResponseHook as ResponseHook
 from typing import Any

logfire_api-5.0.0/logfire_api/_internal/integrations/google_genai.pyi

@@ -0,0 +1,12 @@
+import logfire
+from _typeshed import Incomplete
+from logfire._internal.utils import safe_repr as safe_repr
+from typing import Any
+
+CAPTURE_MESSAGE_CONTENT_ENV_VAR: str
+LEGACY_CAPTURE_MESSAGE_CONTENT_VALUES: Incomplete
+EMIT_EVENT_ENV_VAR: str
+original_flatten_compound_value: Incomplete
+
+def wrapped_flatten_compound_value(key: str, value: Any, *args: Any, **kwargs: Any): ...
+def instrument_google_genai(logfire_instance: logfire.Logfire, **kwargs: Any): ...

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/_internal/integrations/openai_agents.pyi

@@ -7,7 +7,7 @@ from agents.tracing.spans import SpanError, TSpanData
 from dataclasses import dataclass
 from logfire import Logfire as Logfire, LogfireSpan as LogfireSpan
 from logfire._internal.formatter import logfire_format as logfire_format
-from logfire._internal.integrations.llm_providers.openai import inputs_to_events as inputs_to_events, responses_output_events as responses_output_events
+from logfire._internal.integrations.llm_providers.openai import get_openai_usage_attributes as get_openai_usage_attributes, inputs_to_events as inputs_to_events, responses_output_events as responses_output_events
 from logfire._internal.scrubbing import NOOP_SCRUBBER as NOOP_SCRUBBER
 from logfire._internal.utils import handle_internal_errors as handle_internal_errors, log_internal_error as log_internal_error, truncate_string as truncate_string
 from openai.types.responses import Response
@@ -29,6 +29,7 @@ class LogfireTraceProviderWrapper:
 class LogfireSpanHelper:
     span: LogfireSpan
     parent: Trace | Span[Any] | None = ...
+    openai_cost_provider_url: str | None = ...
     def start(self, mark_as_current: bool): ...
     def end(self, reset_current: bool): ...
     def maybe_detach(self, reset_current: bool): ...
@@ -94,7 +95,7 @@ class LogfireSpanWrapper(LogfireWrapperBase[Span[TSpanData]], Span[TSpanData]):
     @property
     def tracing_api_key(self) -> str | None: ...
 
-def attributes_from_span_data(span_data: SpanData, msg_template: str) -> dict[str, Any]: ...
+def attributes_from_span_data(span_data: SpanData, msg_template: str, openai_cost_provider_url: str | None = None) -> dict[str, Any]: ...
 def get_basic_response_attributes(response: Response): ...
-def get_magic_response_attributes() -> dict[str, Any]: ...
+def get_magic_response_attributes() -> tuple[dict[str, Any], str | None]: ...
 def get_response_span_events(span: ResponseSpanData): ...

logfire_api-5.0.0/logfire_api/_internal/interactive.pyi

@@ -0,0 +1,53 @@
+from collections.abc import Callable
+from logfire.exceptions import LogfireConfigError as LogfireConfigError
+from typing import TypeVar
+
+T = TypeVar('T')
+
+class NonInteractiveError(LogfireConfigError):
+    """A prompt was needed, but nobody could answer it.
+
+    Carries the guidance the user needs rather than a traceback: the CLI catches this and
+    prints `message` before exiting non-zero. Raised either because `--non-interactive`
+    said so up front (`require_answer`), or because stdin ran out before an answer arrived
+    (`ask_required`) -- the same question/remedy structure either way (only the reason
+    line differs), since both mean the same thing to whoever reads it.
+    """
+
+def set_non_interactive(value: bool) -> None:
+    """Record whether prompts are allowed. Called once, from CLI argument parsing."""
+def is_non_interactive() -> bool:
+    """Whether the caller declared that it cannot answer prompts."""
+def require_answer(question: str, remedy: str, *more_remedies: str) -> None:
+    """Fail instead of prompting, when the caller said it cannot answer.
+
+    At least one remedy is required by the signature: refusing to prompt while offering no
+    way forward just moves the dead end, and telling the caller what to pass is the entire
+    value of failing here rather than blocking.
+
+    Args:
+        question: what would have been asked, in plain terms.
+        remedy: a runnable suggestion.
+        more_remedies: further suggestions. Each is printed on its own line, so each must
+            be individually pasteable -- `--org a|b` is a shell pipeline, not a suggestion.
+    """
+def ask_or_default(ask: Callable[[], T], default: T) -> T:
+    '''Run a prompt, falling back to `default` when stdin runs out before an answer does.
+
+    Mirrors accepting a blank Enter keypress: the caller already declared what "no answer"
+    means by passing this SAME value as the prompt\'s own `default=`, so an exhausted stdin
+    reaches the outcome a person pressing Enter would, rather than an `EOFError` traceback.
+    Only for prompts where that default is genuinely safe to assume -- see `ask_required`
+    for one that has no safe default to fall back on.
+    '''
+def ask_required(ask: Callable[[], T], question: str, remedy: str, *more_remedies: str) -> T:
+    """Run a prompt that has no safe default, raising if stdin runs out before an answer does.
+
+    The reactive half of `require_answer`'s proactive check: that covers a caller who
+    declared `--non-interactive` up front, this covers one that did not but ran out of
+    input anyway -- a command copied out of the docs into an agent, mid-conversation.
+    Raises the same `NonInteractiveError` structure `require_answer` would -- question,
+    then reason, then remedies -- with a reason line naming stdin instead of the flag,
+    since both mean the same thing to whoever reads it: there was no answer, and here is
+    how to supply one.
+    """

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/_internal/main.pyi

@@ -7,7 +7,6 @@ import pydantic_ai
 import pydantic_ai.models
 import requests
 from . import async_ as async_
-from ..experimental.forwarding import ForwardExportRequestResponse as ForwardExportRequestResponse
 from ..integrations.aiohttp_client import RequestHook as AiohttpClientRequestHook, ResponseHook as AiohttpClientResponseHook
 from ..integrations.flask import CommenterOptions as FlaskCommenterOptions, RequestHook as FlaskRequestHook, ResponseHook as FlaskResponseHook
 from ..integrations.httpx import AsyncRequestHook as HttpxAsyncRequestHook, AsyncResponseHook as HttpxAsyncResponseHook, RequestHook as HttpxRequestHook, ResponseHook as HttpxResponseHook
@@ -22,6 +21,7 @@ from .config import GLOBAL_CONFIG as GLOBAL_CONFIG, LogfireConfig as LogfireConf
 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 .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
 from .integrations.asgi import ASGIApp as ASGIApp, ASGIInstrumentKwargs as ASGIInstrumentKwargs
 from .integrations.aws_lambda import LambdaEvent as LambdaEvent, LambdaHandler as LambdaHandler
@@ -367,13 +367,13 @@ class Logfire:
             A new Logfire instance with the given settings applied.
         """
     def force_flush(self, timeout_millis: int = 3000) -> bool:
-        """Force flush all spans and metrics.
+        """Force flush all telemetry and forwarding pipelines.
 
         Args:
             timeout_millis: The timeout in milliseconds.
 
         Returns:
-            Whether the flush of spans was successful.
+            Whether every component that reports a status flushed successfully.
         """
     def url_from_eval(self, report: EvaluationReport[Any, Any, Any]) -> str | None:
         """Generate a Logfire URL to view an evaluation report.
@@ -478,8 +478,10 @@ class Logfire:
                 - `off`: Disable instrumentation.
             include:
                 By default, third party modules are not instrumented. This option allows you to include specific modules.
+                Each entry is a regular expression matched against `module::ModelName` and anchored at the end,
+                so use e.g. `openai.*` rather than `openai`, which would only match a model named `openai`.
             exclude:
-                Exclude specific modules from instrumentation.
+                Exclude specific modules from instrumentation. Matched the same way as `include`.
         """
     @overload
     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: ...
@@ -528,7 +530,7 @@ class Logfire:
                 without waiting for the context manager to be opened,
                 i.e. it's not necessary to use this as a context manager.
         """
-    def instrument_openai(self, openai_client: openai.OpenAI | openai.AsyncOpenAI | type[openai.OpenAI] | type[openai.AsyncOpenAI] | None = None, *, suppress_other_instrumentation: bool = True, version: SemconvVersion | Sequence[SemconvVersion] = 1) -> AbstractContextManager[None]:
+    def instrument_openai(self, openai_client: openai.OpenAI | openai.AsyncOpenAI | type[openai.OpenAI] | type[openai.AsyncOpenAI] | None = None, *, suppress_other_instrumentation: bool = True, version: SemconvVersion | Sequence[SemconvVersion] = 2) -> AbstractContextManager[None]:
         '''Instrument an OpenAI client so that spans are automatically created for each request.
 
         This instruments the [standard OpenAI SDK](https://pypi.org/project/openai/) package, for instrumentation
@@ -579,14 +581,15 @@ class Logfire:
 
             version: The version(s) of the span attribute format to use:
 
-                - `1` (the default): Uses `request_data` and `response_data` attributes.
-                - `\'latest\'`: Uses OpenTelemetry Gen AI semantic convention attributes
+                - `1`: Uses the legacy `request_data` and `response_data` attributes.
+                - `2` (the default): Uses OpenTelemetry Gen AI semantic convention attributes
                   (`gen_ai.input.messages`, `gen_ai.output.messages`, etc.) and omits the full
                   `response_data` attribute. A minimal `request_data` (e.g. `{"model": ...}`) is
-                  still recorded for message template compatibility. This format may change between
-                  releases.
-                - `[1, \'latest\']`: Emits both the full legacy attributes and the semantic convention
-                  attributes simultaneously, useful for migration and testing.
+                  still recorded for message template compatibility.
+                - `\'latest\'`: Uses the latest format, which is currently identical to version 2.
+                  Unlike a numbered version, this format may change between releases.
+                - `[1, 2]` or `[1, \'latest\']`: Emits both the full legacy attributes and the semantic
+                  convention attributes simultaneously, useful for migration and testing.
 
         Returns:
             A context manager that will revert the instrumentation when exited.
@@ -598,7 +601,7 @@ class Logfire:
         For instrumentation of the standard OpenAI SDK package,
         see [`instrument_openai()`][logfire.Logfire.instrument_openai].
         """
-    def instrument_anthropic(self, anthropic_client: anthropic.Anthropic | anthropic.AsyncAnthropic | _AnthropicBedrock | _AsyncAnthropicBedrock | type[anthropic.Anthropic] | type[anthropic.AsyncAnthropic] | type[_AnthropicBedrock] | type[_AsyncAnthropicBedrock] | None = None, *, suppress_other_instrumentation: bool = True, version: SemconvVersion | Sequence[SemconvVersion] = 1) -> AbstractContextManager[None]:
+    def instrument_anthropic(self, anthropic_client: anthropic.Anthropic | anthropic.AsyncAnthropic | _AnthropicBedrock | _AsyncAnthropicBedrock | type[anthropic.Anthropic] | type[anthropic.AsyncAnthropic] | type[_AnthropicBedrock] | type[_AsyncAnthropicBedrock] | None = None, *, suppress_other_instrumentation: bool = True, version: SemconvVersion | Sequence[SemconvVersion] = 2) -> AbstractContextManager[None]:
         '''Instrument an Anthropic client so that spans are automatically created for each request.
 
         The following methods are instrumented for both the sync and async clients:
@@ -644,14 +647,15 @@ class Logfire:
 
             version: The version(s) of the span attribute format to use:
 
-                - `1` (the default): Uses `request_data` and `response_data` attributes.
-                - `\'latest\'`: Uses OpenTelemetry Gen AI semantic convention attributes
+                - `1`: Uses the legacy `request_data` and `response_data` attributes.
+                - `2` (the default): Uses OpenTelemetry Gen AI semantic convention attributes
                   (`gen_ai.input.messages`, `gen_ai.output.messages`, etc.) and omits the full
                   `response_data` attribute. A minimal `request_data` (e.g. `{"model": ...}`) is
-                  still recorded for message template compatibility. This format may change between
-                  releases.
-                - `[1, \'latest\']`: Emits both the full legacy attributes and the semantic convention
-                  attributes simultaneously, useful for migration and testing.
+                  still recorded for message template compatibility.
+                - `\'latest\'`: Uses the latest format, which is currently identical to version 2.
+                  Unlike a numbered version, this format may change between releases.
+                - `[1, 2]` or `[1, \'latest\']`: Emits both the full legacy attributes and the semantic
+                  convention attributes simultaneously, useful for migration and testing.
 
         Returns:
             A context manager that will revert the instrumentation when exited.
@@ -662,7 +666,7 @@ class Logfire:
 
         !!! note
             To capture message contents (i.e. prompts and completions), set the environment variable
-            `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT` to `true`.
+            `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT` to `SPAN_ONLY`.
 
         Uses the `GoogleGenAiSdkInstrumentor().instrument()` method of the
         [`opentelemetry-instrumentation-google-genai`](https://pypi.org/project/opentelemetry-instrumentation-google-genai/)
@@ -1231,7 +1235,7 @@ class Logfire:
         """
     def variables_get(self) -> list[Variable[Any] | TemplateVariable[Any, Any]]:
         """Get all variables registered with this Logfire instance's config."""
-    def variables_push(self, variables: list[Variable[Any] | TemplateVariable[Any, Any]] | None = None, *, dry_run: bool = False, yes: bool = False, strict: bool = False) -> bool:
+    def variables_push(self, variables: list[Variable[Any] | TemplateVariable[Any, Any]] | None = None, *, dry_run: bool = False, yes: bool = False, strict: bool = True) -> bool:
         """Push variable definitions (metadata only) to the configured variable provider.
 
         This method syncs local variable definitions with the provider:
@@ -1248,8 +1252,8 @@ class Logfire:
                 variables registered on `with_settings()` siblings.
             dry_run: If True, only show what would change without applying.
             yes: If True, skip confirmation prompt.
-            strict: If True, fail if any existing label values are incompatible with new schemas
-                or any reference errors are found.
+            strict: If True, fail on incompatible label values, missing references, or template-field issues.
+                Set to False to publish despite those issues. Reference cycles always block the push.
 
         Returns:
             True if changes were applied (or would be applied in dry_run mode), False otherwise.
@@ -1269,7 +1273,7 @@ class Logfire:
                 logfire.variables_push([feature_enabled])
             ```
         """
-    def variables_push_types(self, types: Sequence[type[Any] | tuple[type[Any], str]], *, dry_run: bool = False, yes: bool = False, strict: bool = False) -> bool:
+    def variables_push_types(self, types: Sequence[type[Any] | tuple[type[Any], str]], *, dry_run: bool = False, yes: bool = False, strict: bool = True) -> bool:
         """Push variable type definitions to the configured variable provider.
 
         Variable types are reusable schema definitions that can be referenced by variables.
@@ -1291,7 +1295,7 @@ class Logfire:
             dry_run: If True, only show what would change without applying.
             yes: If True, skip confirmation prompt.
             strict: If True, abort when existing label values are incompatible with
-                the new type schema.
+                the new type schema. Set to False to publish despite these issues.
 
         Returns:
             True if changes were applied (or would be applied in dry_run mode), False otherwise.

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/_internal/stack_info.pyi

@@ -10,7 +10,11 @@ NON_USER_CODE_PREFIXES: tuple[str, ...]
 def add_non_user_code_prefix(path: str | Path) -> None:
     """Add a path to the list of prefixes that are considered non-user code.
 
-    This prevents the stack info from including frames from the given path.
+    This has two effects for code under the given path:
+
+    - Its frames are left out of the stack info recorded on spans and logs.
+    - Its pydantic models aren't instrumented by `logfire.instrument_pydantic` unless
+      [`include`][logfire.PydanticPlugin.include] names them explicitly.
 
     This is for advanced users and shouldn't often be needed.
     By default, the following prefixes are already included:
@@ -38,14 +42,18 @@ def get_user_frame_and_stacklevel() -> tuple[FrameType | None, int]:
     See is_user_code for details.
     Returns `(None, 0)` if no such frame is found.
     """
+def is_non_user_path(path: str | Path) -> bool:
+    """Check if the file path is in a location that doesn't contain user code.
+
+    Specifically the standard library, site-packages (wherever opentelemetry is installed),
+    the logfire package, and anything registered with `add_non_user_code_prefix`.
+    """
 def is_user_code(code: CodeType) -> bool:
     """Check if the code object is from user code.
 
     A code object is not user code if:
     - It is from a file in
-        - the standard library
-        - site-packages (specifically wherever opentelemetry is installed)
-        - the logfire package
+        - a non-user location, see `is_non_user_path`
         - an unknown location (e.g. a dynamically generated code object) indicated by a filename starting with '<'
     - It is a list/dict/set comprehension.
         These are artificial frames only created before Python 3.12,

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/_internal/utils.pyi

@@ -132,6 +132,14 @@ def platform_is_emscripten() -> bool:
 
     Threads cannot be created on Emscripten, so we need to avoid any code that creates threads.
     """
+def platform_is_aws_lambda() -> bool:
+    """Return True when running inside an AWS Lambda function.
+
+    Lambda freezes the execution environment between the end of the init phase and the first
+    invocation (and between invocations), so background work started during init may be
+    interrupted for minutes. `AWS_LAMBDA_FUNCTION_NAME` is set by the runtime in every Lambda
+    execution environment.
+    """
 def canonicalize_exception_traceback(exc: BaseException, seen: set[int] | None = None) -> str:
     """Return a canonical string representation of an exception traceback.
 

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/db_api.pyi

@@ -1,8 +1,12 @@
 from _typeshed import Incomplete
 from collections.abc import Sequence
 from datetime import datetime, timedelta
-from logfire.experimental.query_client import ColumnDetails as ColumnDetails, LogfireQueryClient as LogfireQueryClient
-from typing import Any, overload
+from enum import Enum
+from logfire.query_client import ColumnDetails as ColumnDetails, LogfireQueryClient as LogfireQueryClient
+from typing import Any
+
+class _Unset(Enum):
+    UNSET: str
 
 apilevel: str
 threadsafety: int
@@ -33,7 +37,7 @@ class Connection:
     min_timestamp: Incomplete
     max_timestamp: Incomplete
     limit: Incomplete
-    def __init__(self, client: LogfireQueryClient, *, min_timestamp: datetime | timedelta | None = ..., max_timestamp: datetime | None = None, limit: int = ...) -> None: ...
+    def __init__(self, client: LogfireQueryClient, *, min_timestamp: datetime | timedelta = ..., max_timestamp: datetime | None = None, limit: int = ...) -> None: ...
     def close(self) -> None:
         """Close the connection and the underlying HTTP client."""
     def commit(self) -> None:
@@ -49,14 +53,22 @@ class Cursor:
     """PEP 249 Cursor that executes queries via `LogfireQueryClient.query_json_rows()`."""
     rowcount: int
     arraysize: int
-    max_timestamp: datetime | None
-    limit: int
     def __init__(self, connection: Connection) -> None: ...
     @property
-    def min_timestamp(self) -> datetime | None:
-        """Per-cursor override for the lower `start_timestamp` bound."""
+    def min_timestamp(self) -> datetime:
+        """Lower `start_timestamp` bound, inherited from the connection unless overridden."""
     @min_timestamp.setter
-    def min_timestamp(self, value: datetime | None) -> None: ...
+    def min_timestamp(self, value: datetime) -> None: ...
+    @property
+    def max_timestamp(self) -> datetime | None:
+        """Upper `start_timestamp` bound, inherited from the connection unless overridden."""
+    @max_timestamp.setter
+    def max_timestamp(self, value: datetime | None) -> None: ...
+    @property
+    def limit(self) -> int:
+        """Row limit, inherited from the connection unless overridden."""
+    @limit.setter
+    def limit(self, value: int) -> None: ...
     @property
     def description(self) -> list[tuple[Any, ...]] | None:
         """Column description as a list of 7-tuples per PEP 249.
@@ -92,7 +104,22 @@ class Cursor:
     def __enter__(self) -> Cursor: ...
     def __exit__(self, *args: Any) -> None: ...
 
-@overload
-def connect(read_token: str, base_url: str | None = None, timeout: float = 30.0, *, min_timestamp: None, max_timestamp: datetime | None = None, limit: int = ..., **kwargs: Any) -> Connection: ...
-@overload
-def connect(read_token: str, base_url: str | None = None, timeout: float = 30.0, *, min_timestamp: datetime | timedelta = ..., max_timestamp: datetime | None = None, limit: int = ..., **kwargs: Any) -> Connection: ...
+def connect(read_token: str, base_url: str | None = None, timeout: float = 30.0, *, min_timestamp: datetime | timedelta = ..., max_timestamp: datetime | None = None, limit: int = ..., **kwargs: Any) -> Connection:
+    """Create a PEP 249 connection to the Logfire query API.
+
+    Args:
+        read_token: A Logfire read token for authentication.
+        base_url: Override the default API base URL (inferred from token region).
+        timeout: HTTP request timeout in seconds.
+        min_timestamp: Default lower bound for `start_timestamp` filtering.
+            Accepts a `datetime` for an exact bound, a `timedelta` for a
+            relative window (computed as `now - timedelta`). Defaults to 1 day ago.
+        max_timestamp: Default upper bound for `start_timestamp` filtering.
+        limit: Default row limit per query (max 10,000). When the number of
+            returned rows equals the limit a warning is emitted.
+        **kwargs: Additional keyword arguments forwarded to the underlying
+            `httpx.Client`.
+
+    Returns:
+        A PEP 249 `Connection` object.
+    """

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/experimental/api_client.pyi

@@ -8,8 +8,8 @@ from logfire._internal.stack_info import warn_at_user_stacklevel as warn_at_user
 from pydantic_evals import Case, Dataset
 from pydantic_evals.evaluators import Evaluator, ReportEvaluator
 from types import TracebackType
-from typing import Any, Generic, Literal, TypeVar, overload
-from typing_extensions import NotRequired, Self, TypedDict
+from typing import Any, Generic, Literal, overload
+from typing_extensions import NotRequired, Self, TypeForm, TypeVar, TypedDict
 from uuid import UUID
 
 Case = Any
@@ -19,8 +19,8 @@ ReportEvaluator = Any
 DEFAULT_TIMEOUT: Incomplete
 T = TypeVar('T', bound=BaseClient)
 InputsT = TypeVar('InputsT')
-OutputT = TypeVar('OutputT')
-MetadataT = TypeVar('MetadataT')
+OutputT = TypeVar('OutputT', default=Any)
+MetadataT = TypeVar('MetadataT', default=Any)
 ResponseT = TypeVar('ResponseT')
 
 class EvaluatorSpec(TypedDict):
@@ -424,7 +424,7 @@ class LogfireAPIClient(_BaseLogfireAPIClient[Client]):
     @overload
     def get_dataset(self, id_or_name: str, *, include_cases: Literal[True] = ...) -> ExportedDataset: ...
     @overload
-    def get_dataset(self, id_or_name: str, input_type: type[InputsT], output_type: type[OutputT] | None = None, metadata_type: type[MetadataT] | None = None, *, custom_evaluator_types: Sequence[type[Evaluator[InputsT, OutputT, MetadataT]]] = (), custom_report_evaluator_types: Sequence[type[Any]] = ()) -> Dataset[InputsT, OutputT, MetadataT]: ...
+    def get_dataset(self, id_or_name: str, input_type: TypeForm[InputsT], output_type: TypeForm[OutputT] = ..., metadata_type: TypeForm[MetadataT] = ..., *, custom_evaluator_types: Sequence[type[Evaluator[InputsT, OutputT, MetadataT]]] = (), custom_report_evaluator_types: Sequence[type[Any]] = ()) -> Dataset[InputsT, OutputT, MetadataT]: ...
 
 class AsyncLogfireAPIClient(_BaseLogfireAPIClient[AsyncClient]):
     """Asynchronous client for managing Logfire datasets.
@@ -494,4 +494,4 @@ class AsyncLogfireAPIClient(_BaseLogfireAPIClient[AsyncClient]):
     @overload
     async def get_dataset(self, id_or_name: str, *, include_cases: Literal[True] = ...) -> ExportedDataset: ...
     @overload
-    async def get_dataset(self, id_or_name: str, input_type: type[InputsT], output_type: type[OutputT] | None = None, metadata_type: type[MetadataT] | None = None, *, custom_evaluator_types: Sequence[type[Evaluator[InputsT, OutputT, MetadataT]]] = (), custom_report_evaluator_types: Sequence[type[Any]] = ()) -> Dataset[InputsT, OutputT, MetadataT]: ...
+    async def get_dataset(self, id_or_name: str, input_type: TypeForm[InputsT], output_type: TypeForm[OutputT] = ..., metadata_type: TypeForm[MetadataT] = ..., *, custom_evaluator_types: Sequence[type[Evaluator[InputsT, OutputT, MetadataT]]] = (), custom_report_evaluator_types: Sequence[type[Any]] = ()) -> Dataset[InputsT, OutputT, MetadataT]: ...

{logfire_api-4.41.0 → logfire_api-5.0.0}/logfire_api/integrations/pydantic.pyi

@@ -1,4 +1,5 @@
 from .._internal.config import GLOBAL_CONFIG as GLOBAL_CONFIG, PydanticPlugin as PydanticPlugin
+from .._internal.stack_info import is_non_user_path as is_non_user_path
 from .._internal.utils import get_version as get_version
 from _typeshed import Incomplete
 from dataclasses import dataclass