Release v3.22.0 (#1220)

Author: alexmojaki

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Release Notes
 
+## [v3.22.0] (2025-07-02)
+
+* Add `instrument_google_genai` by @alexmojaki in [#1217](https://github.com/pydantic/logfire/pull/1217)
+* Refactor user tokens, introduce Logfire client by @Viicos in [#981](https://github.com/pydantic/logfire/pull/981)
+* Use new endpoint for project creation by @hramezani in [#1202](https://github.com/pydantic/logfire/pull/1202)
+
 ## [v3.21.2] (2025-06-30)
 
 * Fix importlib resources with auto tracing by @alexmojaki in [#1212](https://github.com/pydantic/logfire/pull/1212)
@@ -758,3 +764,4 @@ First release from new repo!
 [v3.21.0]: https://github.com/pydantic/logfire/compare/v3.20.0...v3.21.0
 [v3.21.1]: https://github.com/pydantic/logfire/compare/v3.21.0...v3.21.1
 [v3.21.2]: https://github.com/pydantic/logfire/compare/v3.21.1...v3.21.2
+[v3.22.0]: https://github.com/pydantic/logfire/compare/v3.21.2...v3.22.0

logfire-api/logfire_api/__init__.pyi

@@ -14,7 +14,7 @@ from .version import VERSION as VERSION
 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_asyncpg', 'instrument_httpx', 'instrument_celery', 'instrument_requests', 'instrument_psycopg', 'instrument_django', 'instrument_flask', 'instrument_starlette', 'instrument_aiohttp_client', 'instrument_aiohttp_server', 'instrument_sqlalchemy', 'instrument_sqlite3', 'instrument_aws_lambda', 'instrument_redis', 'instrument_pymongo', 'instrument_mysql', 'instrument_system_metrics', 'instrument_mcp', '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', 'logfire_info', 'get_baggage', 'set_baggage']
+__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_asyncpg', 'instrument_httpx', 'instrument_celery', 'instrument_requests', 'instrument_psycopg', 'instrument_django', 'instrument_flask', 'instrument_starlette', 'instrument_aiohttp_client', 'instrument_aiohttp_server', 'instrument_sqlalchemy', 'instrument_sqlite3', 'instrument_aws_lambda', 'instrument_redis', 'instrument_pymongo', 'instrument_mysql', 'instrument_system_metrics', 'instrument_mcp', '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', 'logfire_info', 'get_baggage', 'set_baggage']
 
 DEFAULT_LOGFIRE_INSTANCE = Logfire()
 span = DEFAULT_LOGFIRE_INSTANCE.span
@@ -30,6 +30,7 @@ instrument_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
 instrument_openai = DEFAULT_LOGFIRE_INSTANCE.instrument_openai
 instrument_openai_agents = DEFAULT_LOGFIRE_INSTANCE.instrument_openai_agents
 instrument_anthropic = DEFAULT_LOGFIRE_INSTANCE.instrument_anthropic
+instrument_google_genai = DEFAULT_LOGFIRE_INSTANCE.instrument_google_genai
 instrument_asyncpg = DEFAULT_LOGFIRE_INSTANCE.instrument_asyncpg
 instrument_httpx = DEFAULT_LOGFIRE_INSTANCE.instrument_httpx
 instrument_celery = DEFAULT_LOGFIRE_INSTANCE.instrument_celery

logfire-api/logfire_api/_internal/auth.pyi

@@ -1,21 +1,77 @@
 import requests
-from .utils import UnexpectedResponse as UnexpectedResponse
+from .utils import UnexpectedResponse as UnexpectedResponse, read_toml_file as read_toml_file
 from _typeshed import Incomplete
+from dataclasses import dataclass
 from logfire.exceptions import LogfireConfigError as LogfireConfigError
+from pathlib import Path
 from typing import TypedDict
+from typing_extensions import Self
 
 HOME_LOGFIRE: Incomplete
 DEFAULT_FILE: Incomplete
+PYDANTIC_LOGFIRE_TOKEN_PATTERN: Incomplete
+
+class _RegionData(TypedDict):
+    base_url: str
+    gcp_region: str
+
+REGIONS: dict[str, _RegionData]
 
 class UserTokenData(TypedDict):
     """User token data."""
     token: str
     expiration: str
 
-class DefaultFile(TypedDict):
-    """Content of the default.toml file."""
+class UserTokensFileData(TypedDict, total=False):
+    """Content of the file containing the user tokens."""
     tokens: dict[str, UserTokenData]
 
+@dataclass
+class UserToken:
+    """A user token."""
+    token: str
+    base_url: str
+    expiration: str
+    @classmethod
+    def from_user_token_data(cls, base_url: str, token: UserTokenData) -> Self: ...
+    @property
+    def is_expired(self) -> bool:
+        """Whether the token is expired."""
+
+@dataclass
+class UserTokenCollection:
+    """A collection of user tokens, read from a user tokens file.
+
+    Args:
+        path: The path where the user tokens will be stored. If the path doesn't exist,
+            an empty collection is created. Defaults to `~/.logfire/default.toml`.
+    """
+    user_tokens: dict[str, UserToken]
+    path: Path
+    def __init__(self, path: Path | None = None) -> None: ...
+    def get_token(self, base_url: str | None = None) -> UserToken:
+        """Get a user token from the collection.
+
+        Args:
+            base_url: Only look for user tokens valid for this base URL. If not provided,
+                all the tokens of the collection will be considered: if only one token is
+                available, it will be used, otherwise the user will be prompted to choose
+                a token.
+
+        Raises:
+            LogfireConfigError: If no user token is found (no token matched the base URL,
+                the collection is empty, or the selected token is expired).
+        """
+    def is_logged_in(self, base_url: str | None = None) -> bool:
+        """Check whether the user token collection contains at least one valid user token.
+
+        Args:
+            base_url: Only check for user tokens valid for this base URL. If not provided,
+                all the tokens of the collection will be considered.
+        """
+    def add_token(self, base_url: str, token: UserTokenData) -> UserToken:
+        """Add a user token to the collection."""
+
 class NewDeviceFlow(TypedDict):
     """Matches model of the same name in the backend."""
     device_code: str
@@ -47,9 +103,3 @@ def poll_for_token(session: requests.Session, device_code: str, base_api_url: st
     Returns:
         The user token.
     """
-def is_logged_in(data: DefaultFile, logfire_url: str) -> bool:
-    """Check if the user is logged in.
-
-    Returns:
-        True if the user is logged in, False otherwise.
-    """

logfire-api/logfire_api/_internal/client.pyi

@@ -0,0 +1,52 @@
+from .auth import UserToken as UserToken, UserTokenCollection as UserTokenCollection
+from .utils import UnexpectedResponse as UnexpectedResponse
+from _typeshed import Incomplete
+from logfire.exceptions import LogfireConfigError as LogfireConfigError
+from logfire.version import VERSION as VERSION
+from typing import Any
+from typing_extensions import Self
+
+UA_HEADER: Incomplete
+
+class ProjectAlreadyExists(Exception): ...
+
+class InvalidProjectName(Exception):
+    reason: Incomplete
+    def __init__(self, reason: str, /) -> None: ...
+
+class LogfireClient:
+    """A Logfire HTTP client to interact with the API.
+
+    Args:
+        user_token: The user token to use when authenticating against the API.
+    """
+    base_url: Incomplete
+    def __init__(self, user_token: UserToken) -> None: ...
+    @classmethod
+    def from_url(cls, base_url: str | None) -> Self:
+        """Create a client from the provided base URL.
+
+        Args:
+            base_url: The base URL to use when looking for a user token. If `None`, will prompt
+                the user into selecting a token from the token collection (or, if only one available,
+                use it directly). The token collection will be created from the `~/.logfire/default.toml`
+                file (or an empty one if no such file exists).
+        """
+    def get_user_organizations(self) -> list[dict[str, Any]]:
+        """Get the organizations of the logged-in user."""
+    def get_user_information(self) -> dict[str, Any]:
+        """Get information about the logged-in user."""
+    def get_user_projects(self) -> list[dict[str, Any]]:
+        """Get the projects of the logged-in user."""
+    def create_new_project(self, organization: str, project_name: str):
+        """Create a new project.
+
+        Args:
+            organization: The organization that should hold the new project.
+            project_name: The name of the project to be created.
+
+        Returns:
+            The newly created project.
+        """
+    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."""

logfire-api/logfire_api/_internal/config.pyi

@@ -1,7 +1,7 @@
 import dataclasses
 import requests
 from ..propagate import NoExtractTraceContextPropagator as NoExtractTraceContextPropagator, WarnOnExtractTraceContextPropagator as WarnOnExtractTraceContextPropagator
-from .auth import DEFAULT_FILE as DEFAULT_FILE, DefaultFile as DefaultFile, is_logged_in as is_logged_in
+from .client import InvalidProjectName as InvalidProjectName, LogfireClient as LogfireClient, ProjectAlreadyExists as ProjectAlreadyExists
 from .config_params import ParamManager as ParamManager, PydanticPluginRecordValues as PydanticPluginRecordValues
 from .constants import 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
 from .exporters.console import ConsoleColorsValues as ConsoleColorsValues, ConsoleLogExporter as ConsoleLogExporter, IndentedConsoleSpanExporter as IndentedConsoleSpanExporter, ShowParentsConsoleSpanExporter as ShowParentsConsoleSpanExporter, SimpleConsoleSpanExporter as SimpleConsoleSpanExporter
@@ -19,10 +19,11 @@ from .metrics import ProxyMeterProvider as ProxyMeterProvider
 from .scrubbing import BaseScrubber as BaseScrubber, NOOP_SCRUBBER as NOOP_SCRUBBER, Scrubber as Scrubber, ScrubbingOptions as ScrubbingOptions
 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, UnexpectedResponse as UnexpectedResponse, ensure_data_dir_exists as ensure_data_dir_exists, handle_internal_errors as handle_internal_errors, platform_is_emscripten as platform_is_emscripten, read_toml_file as read_toml_file, 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_emscripten as platform_is_emscripten, suppress_instrumentation as suppress_instrumentation
 from _typeshed import Incomplete
 from collections.abc import Sequence
 from dataclasses import dataclass, field
+from logfire._internal.auth import PYDANTIC_LOGFIRE_TOKEN_PATTERN as PYDANTIC_LOGFIRE_TOKEN_PATTERN, REGIONS as REGIONS
 from logfire._internal.baggage import DirectBaggageAttributesSpanProcessor as DirectBaggageAttributesSpanProcessor
 from logfire.exceptions import LogfireConfigError as LogfireConfigError
 from logfire.sampling import SamplingOptions as SamplingOptions
@@ -40,15 +41,8 @@ from typing_extensions import Self, Unpack
 CREDENTIALS_FILENAME: str
 COMMON_REQUEST_HEADERS: Incomplete
 PROJECT_NAME_PATTERN: str
-PYDANTIC_LOGFIRE_TOKEN_PATTERN: Incomplete
 METRICS_PREFERRED_TEMPORALITY: Incomplete
 
-class _RegionData(TypedDict):
-    base_url: str
-    gcp_region: str
-
-REGIONS: dict[str, _RegionData]
-
 @dataclass
 class ConsoleOptions:
     """Options for controlling console output."""
@@ -270,31 +264,14 @@ class LogfireCredentials:
             LogfireConfigError: If the token is invalid.
         """
     @classmethod
-    def get_current_user(cls, session: requests.Session, logfire_api_url: str | None = None) -> dict[str, Any] | None: ...
-    @classmethod
-    def get_user_projects(cls, session: requests.Session, logfire_api_url: str | None = None) -> list[dict[str, Any]]:
-        """Get list of projects that user has access to them.
-
-        Args:
-            session: HTTP client session used to communicate with the Logfire API.
-            logfire_api_url: The Logfire API base URL.
-
-        Returns:
-            List of user projects.
-
-        Raises:
-            LogfireConfigError: If there was an error retrieving user projects.
-        """
-    @classmethod
-    def use_existing_project(cls, *, session: requests.Session, projects: list[dict[str, Any]], logfire_api_url: str | None = None, organization: str | None = None, project_name: str | None = None) -> dict[str, Any] | None:
+    def use_existing_project(cls, *, client: LogfireClient, projects: list[dict[str, Any]], organization: str | None = None, project_name: str | None = None) -> dict[str, Any] | None:
         """Configure one of the user projects to be used by Logfire.
 
         It configures the project if organization/project_name is a valid project that
         the user has access to it. Otherwise, it asks the user to select a project interactively.
 
         Args:
-            session: HTTP client session used to communicate with the Logfire API.
-            logfire_api_url: The Logfire API base URL.
+            client: The Logfire client to use when making requests.
             projects: List of user projects.
             organization: Project organization.
             project_name: Name of project that has to be used.
@@ -306,15 +283,14 @@ class LogfireCredentials:
             LogfireConfigError: If there was an error configuring the project.
         """
     @classmethod
-    def create_new_project(cls, *, session: requests.Session, logfire_api_url: str | None = None, organization: str | None = None, default_organization: bool = False, project_name: str | None = None) -> dict[str, Any]:
+    def create_new_project(cls, *, client: LogfireClient, organization: str | None = None, default_organization: bool = False, project_name: str | None = None) -> dict[str, Any]:
         """Create a new project and configure it to be used by Logfire.
 
         It creates the project under the organization if both project and organization are valid.
         Otherwise, it asks the user to select organization and enter a valid project name interactively.
 
         Args:
-            session: HTTP client session used to communicate with the Logfire API.
-            logfire_api_url: The Logfire API base URL.
+            client: The Logfire client to use when making requests.
             organization: The organization name of the new project.
             default_organization: Whether to create the project under the user default organization.
             project_name: The default name of the project.
@@ -326,12 +302,11 @@ class LogfireCredentials:
             LogfireConfigError: If there was an error creating projects.
         """
     @classmethod
-    def initialize_project(cls, *, session: requests.Session, logfire_api_url: str | None = None) -> Self:
+    def initialize_project(cls, *, client: LogfireClient) -> Self:
         """Create a new project or use an existing project on logfire.dev requesting the given project name.
 
         Args:
-            session: HTTP client session used to communicate with the Logfire API.
-            logfire_api_url: The Logfire API base URL.
+            client: The Logfire client to use when making requests.
 
         Returns:
             The new credentials.

logfire-api/logfire_api/_internal/exporters/processor_wrapper.pyi

@@ -2,11 +2,11 @@ from ..constants import ATTRIBUTES_JSON_SCHEMA_KEY as ATTRIBUTES_JSON_SCHEMA_KEY
 from ..db_statement_summary import message_from_db_statement as message_from_db_statement
 from ..json_schema import JsonSchemaProperties as JsonSchemaProperties, attributes_json_schema as attributes_json_schema
 from ..scrubbing import BaseScrubber as BaseScrubber
-from ..utils import ReadableSpanDict as ReadableSpanDict, is_asgi_send_receive_span_name as is_asgi_send_receive_span_name, is_instrumentation_suppressed as is_instrumentation_suppressed, span_to_dict as span_to_dict, truncate_string as truncate_string
+from ..utils import ReadableSpanDict as ReadableSpanDict, handle_internal_errors as handle_internal_errors, is_asgi_send_receive_span_name as is_asgi_send_receive_span_name, is_instrumentation_suppressed as is_instrumentation_suppressed, span_to_dict as span_to_dict, truncate_string as truncate_string
 from .wrapper import WrapperSpanProcessor as WrapperSpanProcessor
 from dataclasses import dataclass
 from opentelemetry import context
-from opentelemetry.sdk.trace import ReadableSpan, Span
+from opentelemetry.sdk.trace import Event as Event, ReadableSpan, Span
 
 class CheckSuppressInstrumentationProcessorWrapper(WrapperSpanProcessor):
     """Checks if instrumentation is suppressed, then suppresses instrumentation itself.

logfire-api/logfire_api/_internal/integrations/google_genai.pyi

@@ -0,0 +1,13 @@
+import logfire
+from logfire._internal.utils import handle_internal_errors as handle_internal_errors
+from opentelemetry._events import Event, EventLogger, EventLoggerProvider
+from typing import Any
+
+class SpanEventLogger(EventLogger):
+    @handle_internal_errors
+    def emit(self, event: Event) -> None: ...
+
+class SpanEventLoggerProvider(EventLoggerProvider):
+    def get_event_logger(self, *args: Any, **kwargs: Any) -> SpanEventLogger: ...
+
+def instrument_google_genai(logfire_instance: logfire.Logfire): ...

logfire-api/logfire_api/_internal/main.pyi

@@ -579,6 +579,7 @@ class Logfire:
             A context manager that will revert the instrumentation when exited.
                 Use of this context manager is optional.
         """
+    def instrument_google_genai(self) -> None: ...
     def instrument_asyncpg(self, **kwargs: Any) -> None:
         """Instrument the `asyncpg` module so that spans are automatically created for each query."""
     @overload

logfire-api/logfire_api/_internal/utils.pyi

@@ -68,6 +68,7 @@ def span_to_dict(span: ReadableSpan) -> ReadableSpanDict:
 
 class UnexpectedResponse(RequestException):
     """An unexpected response was received from the server."""
+    response: Response
     def __init__(self, response: Response) -> None: ...
     @classmethod
     def raise_for_status(cls, response: Response) -> None:

logfire-api/pyproject.toml

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