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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: logfire-api
-Version: 4.40.0
+Version: 4.41.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.40.0 → logfire_api-4.41.0}/logfire_api/_internal/cli/__init__.pyi

@@ -1,9 +1,13 @@
 import argparse
 from collections.abc import Sequence
-from typing import Any
+from typing import Any, NamedTuple
 
 __all__ = ['main', 'logfire_info']
 
+class SavedReadToken(NamedTuple):
+    token: str
+    base_url: str
+
 def logfire_info() -> str:
     """Show versions of logfire, OS and related packages."""
 

{logfire_api-4.40.0 → logfire_api-4.41.0}/logfire_api/_internal/cli/auth.pyi

@@ -2,6 +2,7 @@ import argparse
 from ...exceptions import LogfireConfigError as LogfireConfigError
 from ..auth import DEFAULT_FILE as DEFAULT_FILE, UserTokenCollection as UserTokenCollection, poll_for_token as poll_for_token, request_device_code as request_device_code
 from ..config import REGIONS as REGIONS
+from ..interactive import is_non_interactive as is_non_interactive, require_answer as require_answer
 
 def parse_auth(args: argparse.Namespace) -> None:
     """Authenticate with Logfire.

{logfire_api-4.40.0 → logfire_api-4.41.0}/logfire_api/_internal/cli/gateway.pyi

@@ -1,5 +1,6 @@
 import argparse
 import httpx
+from ..interactive import require_answer as require_answer
 from .ai_tools import AiToolIntegration as AiToolIntegration, LOCAL_TOKEN_PLACEHOLDER as LOCAL_TOKEN_PLACEHOLDER, ai_tool_names as ai_tool_names, gateway_template_values as gateway_template_values, resolve_ai_tool as resolve_ai_tool
 from .gateway_auth import CimdOAuthClient as CimdOAuthClient, GATEWAY_CIMD_PATH as GATEWAY_CIMD_PATH, GatewayAuth as GatewayAuth, GatewayError as GatewayError, OAuthSession as OAuthSession, discover_oauth_metadata as discover_oauth_metadata
 from _typeshed import Incomplete

{logfire_api-4.40.0 → logfire_api-4.41.0}/logfire_api/_internal/client.pyi

@@ -1,7 +1,9 @@
 from .auth import UserToken as UserToken, UserTokenCollection as UserTokenCollection
+from .constants import HTTP_CONNECT_TIMEOUT as HTTP_CONNECT_TIMEOUT
 from .server_response import ServerResponseCallback as ServerResponseCallback, install_logfire_response_hook as install_logfire_response_hook
 from .utils import UnexpectedResponse as UnexpectedResponse
 from _typeshed import Incomplete
+from datetime import datetime
 from logfire.exceptions import LogfireConfigError as LogfireConfigError
 from logfire.version import VERSION as VERSION
 from typing import Any
@@ -55,7 +57,12 @@ class LogfireClient:
         """
     def create_write_token(self, organization: str, project_name: str) -> dict[str, Any]:
         """Create a write token for the given project in the given organization."""
-    def create_read_token(self, organization: str, project_name: str) -> dict[str, Any]:
-        """Create a read token for the given project in the given organization."""
+    def create_read_token(self, organization: str, project_name: str, expires_at: datetime | None = None) -> dict[str, Any]:
+        """Create a read token for the given project in the given organization.
+
+        `expires_at` bounds how long the token stays valid. The CLI has no way to revoke
+        one, so a token it stores on disk gets an expiry; a token it prints for the caller
+        to place somewhere else does not, because we do not know what it was used for.
+        """
     def get_prompt(self, organization: str, project_name: str, issue: str) -> dict[str, Any]:
         """Get a prompt to be used with your favorite LLM."""

{logfire_api-4.40.0 → logfire_api-4.41.0}/logfire_api/_internal/collect_system_info.pyi

@@ -5,5 +5,5 @@ def collect_package_info() -> dict[str, str]:
     """Retrieve the package information for all installed packages.
 
     Returns:
-        A dicts with the package name and version.
+        A dict with the package name and version.
     """

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

@@ -16,6 +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 .logs import ProxyLoggerProvider as ProxyLoggerProvider
 from .main import Logfire as Logfire
 from .metrics import ProxyMeterProvider as ProxyMeterProvider
@@ -76,7 +77,12 @@ class AdvancedOptions:
     emit_configuration_span: bool | None = ...
     server_response_hook: ServerResponseCallback | None = ...
     resource_detectors: Sequence[ResourceDetector | str] | None = ...
-    def generate_base_url(self, token: str) -> str: ...
+    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`.
+
+        Unknown regions warn by default. The background credential check opts out because the
+        synchronous exporter setup has already emitted the same warning.
+        """
 
 @dataclass
 class PydanticPlugin:
@@ -192,7 +198,7 @@ def configure(*, local: bool = False, send_to_logfire: bool | Literal['if-token-
             or provide a `MetricsOptions` object to configure metrics, e.g. additional metric readers.
         scrubbing: Options for scrubbing sensitive data. Set to `False` to disable.
         inspect_arguments: Whether to enable
-            [f-string magic](https://logfire.pydantic.dev/docs/guides/onboarding-checklist/add-manual-tracing/#f-strings).
+            [f-string magic](https://pydantic.dev/docs/logfire/instrument/python/add-manual-tracing/#f-strings).
             If `None` uses the `LOGFIRE_INSPECT_ARGUMENTS` environment variable.
 
             Defaults to `True` if and only if the Python version is at least 3.11.
@@ -416,8 +422,15 @@ class LogfireCredentials:
     def print_token_summary(self) -> None:
         """Print a summary of the existing project."""
 
-def get_base_url_from_token(token: str) -> str:
-    """Get the base API URL from the token's region."""
+def get_base_url_from_token(token: str, warn_unknown_region: bool = True) -> str:
+    """Get the base API URL from the token's region.
+
+    Args:
+        token: The Logfire token to read the region from.
+        warn_unknown_region: Whether to emit a `LogfireConfigWarning` when the token's region is
+            unrecognised and the US region is used as a fallback. This is on by default for every
+            caller; disable it only when the same token has already produced the warning.
+    """
 def get_git_revision_hash() -> str:
     """Get the current git commit hash."""
 def sanitize_project_name(name: str) -> str:

{logfire_api-4.40.0 → logfire_api-4.41.0}/logfire_api/_internal/constants.pyi

@@ -36,4 +36,5 @@ CONTEXT_ATTRIBUTES_KEY: Incomplete
 CONTEXT_SAMPLE_RATE_KEY: Incomplete
 MESSAGE_FORMATTED_VALUE_LENGTH_LIMIT: int
 ONE_SECOND_IN_NANOSECONDS: int
+HTTP_CONNECT_TIMEOUT: int
 ATTRIBUTES_EXCEPTION_FINGERPRINT_KEY: str

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

@@ -1,5 +1,6 @@
 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 .wrapper import WrapperLogExporter as WrapperLogExporter, WrapperSpanExporter as WrapperSpanExporter
 from _typeshed import Incomplete
@@ -25,6 +26,7 @@ class BodySizeCheckingOTLPSpanExporter(OTLPSpanExporter):
 
 class OTLPExporterHttpSession(Session):
     """A requests.Session subclass that defers failed requests to a DiskRetryer."""
+    def request(self, method: str, url: str, **kwargs: Any): ...
     def post(self, url: str, data: bytes, **kwargs: Any): ...
     @cached_property
     def retryer(self) -> DiskRetryer: ...

{logfire_api-4.40.0 → logfire_api-4.41.0}/logfire_api/_internal/integrations/claude_agent_sdk.pyi

@@ -4,6 +4,7 @@ from claude_agent_sdk.types import HookContext, SyncHookJSONOutput
 from contextlib import AbstractContextManager
 from logfire._internal.integrations.llm_providers.semconv import CONVERSATION_ID as CONVERSATION_ID, ChatMessage as ChatMessage, ERROR_TYPE as ERROR_TYPE, INPUT_MESSAGES as INPUT_MESSAGES, MessagePart as MessagePart, OPERATION_NAME as OPERATION_NAME, OUTPUT_MESSAGES as OUTPUT_MESSAGES, OutputMessage as OutputMessage, PROVIDER_NAME as PROVIDER_NAME, REQUEST_MODEL as REQUEST_MODEL, RESPONSE_MODEL as RESPONSE_MODEL, ReasoningPart as ReasoningPart, SYSTEM as SYSTEM, SYSTEM_INSTRUCTIONS as SYSTEM_INSTRUCTIONS, TOOL_CALL_ARGUMENTS as TOOL_CALL_ARGUMENTS, TOOL_CALL_ID as TOOL_CALL_ID, TOOL_CALL_RESULT as TOOL_CALL_RESULT, TOOL_NAME as TOOL_NAME, TextPart as TextPart, ToolCallPart as ToolCallPart, ToolCallResponsePart as ToolCallResponsePart
 from logfire._internal.main import Logfire as Logfire, LogfireSpan as LogfireSpan
+from logfire._internal.stack_info import get_user_stack_info as get_user_stack_info
 from logfire._internal.utils import handle_internal_errors as handle_internal_errors
 from typing import Any
 
@@ -35,7 +36,19 @@ class _ConversationState:
     root_span: Incomplete
     active_tool_spans: dict[str, LogfireSpan]
     model: str | None
+    announced_tool_ids: set[str]
+    tool_announcement_timeout: float
+    code_attrs: Incomplete
     def __init__(self, *, logfire: Logfire, root_span: LogfireSpan, input_messages: list[ChatMessage], system_instructions: list[TextPart] | None = None) -> None: ...
+    async def wait_for_tool_announcement(self, tool_use_id: str) -> None:
+        """Wait until the assistant message announcing `tool_use_id` has been handled.
+
+        The CLI sends the assistant message (containing the `tool_use` block) before it
+        invokes the PreToolUse hook, but hooks run in separate anyio tasks, so the hook
+        can be scheduled before the main task has applied that message to this state.
+        Closing the chat span at that point would lose its output and model attributes.
+        The timeout is a safety valve for tool calls that are never announced.
+        """
     def add_tool_result(self, tool_use_id: str, tool_name: str, result: Any) -> None:
         """Record a tool result to include in the next chat span's input messages."""
     def open_chat_span(self) -> None:

logfire_api-4.41.0/logfire_api/_internal/integrations/system_metrics.pyi

@@ -0,0 +1,49 @@
+from _typeshed import Incomplete
+from collections.abc import Iterable
+from logfire import Logfire as Logfire
+from typing import Literal
+from typing_extensions import LiteralString
+
+MetricName: type[Literal['system.cpu.simple_utilization', 'system.cpu.time', 'system.cpu.utilization', 'system.cpu.load_average.1m', 'system.memory.usage', 'system.memory.utilization', 'system.swap.usage', 'system.swap.utilization', 'system.disk.io', 'system.disk.operations', 'system.disk.time', 'system.network.dropped.packets', 'system.network.packets', 'system.network.errors', 'system.network.io', 'system.network.connections', 'system.process.count', 'system.thread_count', 'process.open_file_descriptor.count', 'process.context_switches', 'process.cpu.time', 'process.cpu.utilization', 'process.cpu.core_utilization', 'process.disk.io', 'process.memory.usage', 'process.memory.virtual', 'process.thread.count', 'process.runtime.gc_count', 'cpython.gc.collected_objects', 'cpython.gc.collections', 'cpython.gc.uncollectable_objects']]
+Config = dict[MetricName, Iterable[str] | None]
+CPU_FIELDS: list[LiteralString]
+MEMORY_FIELDS: list[LiteralString]
+FULL_CONFIG: Config
+BASIC_CONFIG: Config
+Base: Incomplete
+
+def get_base_config(base: Base) -> Config: ...
+def instrument_system_metrics(logfire_instance: Logfire, config: Config | None = None, base: Base = 'basic'): ...
+def measure_simple_cpu_utilization(logfire_instance: Logfire): ...
+def measure_process_runtime_cpu_utilization(logfire_instance: Logfire): ...
+def measure_process_cpu_utilization(logfire_instance: Logfire): ...
+def measure_process_cpu_core_utilization(logfire_instance: Logfire):
+    """Same as process.cpu.utilization, but not divided by the number of available cores."""
+def measure_system_cpu_load_average_1m(logfire_instance: Logfire):
+    """1-minute system load average.
+
+    OTel semconv defines no load average metric. The system metrics spec only
+    floats `system.linux.cpu.load_1m` as a hypothetical illustration of OS-prefixed
+    naming, so there's nothing to conform to. The name, gauge instrument, and
+    `{thread}` unit here match the OTel Collector's `hostmetrics` load scraper,
+    which is where most host load averages reaching Logfire come from. Matching it
+    means SDK-reported and Collector-reported hosts land on one series instead of two.
+
+    Upstream `SystemMetricsInstrumentor` doesn't emit this. On Windows,
+    `psutil.getloadavg()` is an emulated polling shim — the first call returns 0
+    and subsequent values update every ~5s.
+    """
+def measure_system_process_count(logfire_instance: Logfire):
+    """Total number of processes on the system.
+
+    Name, instrument, and unit follow OTel semconv's `system.process.count`
+    (an UpDownCounter in `{process}`). Its `process.state` attribute is omitted:
+    `psutil.pids()` is a single cheap syscall, while splitting by state needs a
+    `process_iter` over every process and multiplies the series count. This metric
+    is in the basic base, so that cost would land on every default install.
+
+    Note that the OTel Collector's `hostmetrics` receiver still emits the older
+    `system.processes.count` for the same measurement.
+
+    Upstream `SystemMetricsInstrumentor` doesn't emit this.
+    """

logfire_api-4.41.0/logfire_api/_internal/interactive.pyi

@@ -0,0 +1,26 @@
+from logfire.exceptions import LogfireConfigError as LogfireConfigError
+
+class NonInteractiveError(LogfireConfigError):
+    """A prompt was needed, but `--non-interactive` says nobody can answer it.
+
+    Carries the guidance the user needs rather than a traceback: the CLI catches this and
+    prints `message` before exiting non-zero.
+    """
+
+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.
+    """

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

@@ -402,7 +402,7 @@ class Logfire:
     def install_auto_tracing(self, modules: Sequence[str] | Callable[[AutoTraceModule], bool], *, min_duration: float, check_imported_modules: Literal['error', 'warn', 'ignore'] = 'error') -> None:
         """Install automatic tracing.
 
-        See the [Auto-Tracing guide](https://pydantic.dev/docs/logfire/instrument/add-auto-tracing/)
+        See the [Auto-Tracing guide](https://pydantic.dev/docs/logfire/instrument/python/add-auto-tracing/)
         for more info.
 
         This will trace all non-generator function calls in the modules specified by the modules argument.
@@ -1443,7 +1443,7 @@ class Logfire:
 
         This is for proxying telemetry from a browser to Logfire so that the write token doesn\'t need to be
         exposed in the frontend code.
-        See https://pydantic.dev/docs/logfire/typescript-sdk/packages/browser/#python-backend-proxy
+        See https://pydantic.dev/docs/logfire/instrument/typescript/packages/browser/#python-backend-proxy
         for more details.
 
         We recommend protecting the endpoint that uses this method with authentication, rate limiting, and CORS.
@@ -1466,7 +1466,7 @@ class Logfire:
 
         This is for proxying telemetry from a browser to Logfire so that the write token doesn't need to be
         exposed in the frontend code.
-        See https://pydantic.dev/docs/logfire/typescript-sdk/packages/browser/#python-backend-proxy
+        See https://pydantic.dev/docs/logfire/instrument/typescript/packages/browser/#python-backend-proxy
         for more details.
 
         We recommend protecting the endpoint that uses this method with authentication, rate limiting, and CORS.

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

@@ -78,6 +78,9 @@ class UnexpectedResponse(RequestException):
     def raise_for_status(cls, response: Response) -> None:
         """Like the requests method, but raises a more informative exception."""
 
+READ_TOKEN_FILENAME: str
+DATA_DIR_FILENAMES: Incomplete
+
 def ensure_data_dir_exists(data_dir: Path) -> None: ...
 def get_version(version: str) -> Version:
     """Return a packaging.version.Version object from a version string.

{logfire_api-4.40.0 → logfire_api-4.41.0}/pyproject.toml

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

logfire_api-4.40.0/logfire_api/_internal/integrations/system_metrics.pyi

@@ -1,21 +0,0 @@
-from _typeshed import Incomplete
-from collections.abc import Iterable
-from logfire import Logfire as Logfire
-from typing import Literal
-from typing_extensions import LiteralString
-
-MetricName: type[Literal['system.cpu.simple_utilization', 'system.cpu.time', 'system.cpu.utilization', 'system.memory.usage', 'system.memory.utilization', 'system.swap.usage', 'system.swap.utilization', 'system.disk.io', 'system.disk.operations', 'system.disk.time', 'system.network.dropped.packets', 'system.network.packets', 'system.network.errors', 'system.network.io', 'system.network.connections', 'system.thread_count', 'process.open_file_descriptor.count', 'process.context_switches', 'process.cpu.time', 'process.cpu.utilization', 'process.cpu.core_utilization', 'process.disk.io', 'process.memory.usage', 'process.memory.virtual', 'process.thread.count', 'process.runtime.gc_count', 'cpython.gc.collected_objects', 'cpython.gc.collections', 'cpython.gc.uncollectable_objects']]
-Config = dict[MetricName, Iterable[str] | None]
-CPU_FIELDS: list[LiteralString]
-MEMORY_FIELDS: list[LiteralString]
-FULL_CONFIG: Config
-BASIC_CONFIG: Config
-Base: Incomplete
-
-def get_base_config(base: Base) -> Config: ...
-def instrument_system_metrics(logfire_instance: Logfire, config: Config | None = None, base: Base = 'basic'): ...
-def measure_simple_cpu_utilization(logfire_instance: Logfire): ...
-def measure_process_runtime_cpu_utilization(logfire_instance: Logfire): ...
-def measure_process_cpu_utilization(logfire_instance: Logfire): ...
-def measure_process_cpu_core_utilization(logfire_instance: Logfire):
-    """Same as process.cpu.utilization, but not divided by the number of available cores."""