From f8d4c391a83229fab32938397d8bab3f90f62fc4 Mon Sep 17 00:00:00 2001
From: Alex Hall <alex.mojaki@gmail.com>
Date: Fri, 27 Sep 2024 14:59:28 +0200
Subject: [PATCH] Replace `pydantic_plugin` in `logfire.configure()` with
 `logfire.instrument_pydantic()` (#453)

---
 docs/integrations/pydantic.md                 | 28 +++++-----
 docs/integrations/third-party/mirascope.md    |  5 +-
 docs/why-logfire/pydantic.md                  |  5 +-
 logfire-api/logfire_api/__init__.py           |  3 ++
 logfire-api/logfire_api/__init__.pyi          |  3 +-
 logfire-api/logfire_api/_internal/config.pyi  | 16 +++---
 .../logfire_api/_internal/config_params.pyi   |  2 -
 logfire-api/logfire_api/_internal/main.pyi    | 21 +++++++-
 logfire-api/logfire_api/_internal/utils.pyi   | 19 +++++++
 .../logfire_api/integrations/pydantic.pyi     |  6 ++-
 logfire/__init__.py                           |  2 +
 logfire/_internal/config.py                   | 40 ++++++--------
 logfire/_internal/config_params.py            |  7 +--
 logfire/_internal/main.py                     | 51 +++++++++++++++++-
 logfire/integrations/pydantic.py              | 23 +++++---
 tests/conftest.py                             |  6 +++
 tests/test_configure.py                       | 54 +++++++++++++------
 tests/test_pydantic_plugin.py                 | 21 ++++----
 18 files changed, 215 insertions(+), 97 deletions(-)

diff --git a/docs/integrations/pydantic.md b/docs/integrations/pydantic.md
index 443fd381d..ca133d32f 100644
--- a/docs/integrations/pydantic.md
+++ b/docs/integrations/pydantic.md
@@ -1,6 +1,6 @@
 # Pydantic
 
-Logfire has a [Pydantic plugin][pydantic-plugin] to instrument [Pydantic][pydantic] models.
+Logfire has a Pydantic plugin to instrument [Pydantic][pydantic] models.
 The plugin provides logs and metrics about model validation.
 
 To enable the plugin, do one of the following:
@@ -13,35 +13,36 @@ To enable the plugin, do one of the following:
 pydantic_plugin_record = "all"
 ```
 
-- Use the [`pydantic_plugin`][logfire.configure(pydantic_plugin)] parameter in `logfire.configure`, e.g:
+- Call [`logfire.instrument_pydantic`][logfire.Logfire.instrument_pydantic] with the desired configuration, e.g:
 
 ```py
 import logfire
 
-logfire.configure(pydantic_plugin=logfire.PydanticPlugin(record='all'))
+logfire.instrument_pydantic()  # Defaults to record='all'
 ```
 
-Note that if you only use the last option then only models defined and imported *after* calling `logfire.configure`
+Note that if you only use the last option then only model classes defined and imported *after* calling `logfire.instrument_pydantic`
 will be instrumented.
 
+!!! note
+    Remember to call [`logfire.configure()`][logfire.configure] at some point, whether before or after
+    calling `logfire.instrument_pydantic` and defining model classes.
+    Model validations will only start being logged after calling `logfire.configure()`.
+
 ## Third party modules
 
 By default, third party modules are not instrumented by the plugin to avoid noise. You can enable instrumentation for those
 using the [`include`][logfire.PydanticPlugin.include] configuration.
 
 ```py
-import logfire
-
-logfire.configure(pydantic_plugin=logfire.PydanticPlugin(record='all', include={'openai'}))
+logfire.instrument_pydantic(include={'openai'})
 ```
 
 You can also disable instrumentation for your own modules using the
 [`exclude`][logfire.PydanticPlugin.exclude] configuration.
 
 ```py
-import logfire
-
-logfire.configure(pydantic_plugin=logfire.PydanticPlugin(record='all', exclude={'app.api.v1'}))
+logfire.instrument_pydantic(exclude={'app.api.v1'})
 ```
 
 ## Model configuration
@@ -60,13 +61,13 @@ class Foo(BaseModel, plugin_settings=PluginSettings(logfire={'record': 'failure'
 
 ### Record
 
-The [`record`][logfire.integrations.pydantic.LogfireSettings.record] is used to configure what to record.
+The [`record`][logfire.integrations.pydantic.LogfireSettings.record] argument is used to configure what to record.
 It can be one of the following values:
 
-  * `off`: Disable instrumentation. This is default value.
-  * `all`: Send traces and metrics for all events.
+  * `all`: Send traces and metrics for all events. This is default value for `logfire.instrument_pydantic`.
   * `failure`: Send metrics for all validations and traces only for validation failures.
   * `metrics`: Send only metrics.
+  * `off`: Disable instrumentation.
 
 <!--
 [Sampling](../usage/sampling.md) can be configured by `trace_sample_rate` key in
@@ -98,4 +99,3 @@ class Foo(
 ```
 
 [pydantic]: https://docs.pydantic.dev/latest/
-[pydantic-plugin]: https://docs.pydantic.dev/latest/concepts/plugins/
diff --git a/docs/integrations/third-party/mirascope.md b/docs/integrations/third-party/mirascope.md
index b0a3c58ba..b6091023b 100644
--- a/docs/integrations/third-party/mirascope.md
+++ b/docs/integrations/third-party/mirascope.md
@@ -32,7 +32,7 @@ This will give you:
   <figcaption>Mirascope Anthropic call span and Anthropic span and conversation</figcaption>
 </figure>
 
-Since Mirascope is built on top of [Pydantic][pydantic], you can use the [Pydantic plugin][pydantic-plugin] to track additional logs and metrics about model validation, which you can enable using the [`pydantic_plugin`][logfire.configure(pydantic_plugin)] configuration.
+Since Mirascope is built on top of [Pydantic][pydantic], you can use the [Pydantic plugin](../pydantic.md) to track additional logs and metrics about model validation.
 
 This can be particularly useful when [extracting structured information][mirascope-extracting-structured-information] using LLMs:
 
@@ -44,7 +44,8 @@ from mirascope.core import openai, prompt_template
 from mirascope.integrations.logfire import with_logfire
 from pydantic import BaseModel
 
-logfire.configure(pydantic_plugin=logfire.PydanticPlugin(record="all"))
+logfire.configure()
+logfire.instrument_pydantic()
 
 
 class TaskDetails(BaseModel):
diff --git a/docs/why-logfire/pydantic.md b/docs/why-logfire/pydantic.md
index ab3d227e1..1b837abe3 100644
--- a/docs/why-logfire/pydantic.md
+++ b/docs/why-logfire/pydantic.md
@@ -31,7 +31,8 @@ from datetime import date
 import logfire
 from pydantic import BaseModel
 
-logfire.configure(pydantic_plugin=logfire.PydanticPlugin(record='all'))  # (1)!
+logfire.configure()
+logfire.instrument_pydantic()  # (1)!
 
 class User(BaseModel):
     name: str
@@ -43,7 +44,7 @@ User(name='Ben', country_code='USA', dob='2000-02-02')
 User(name='Charlie', country_code='GBR', dob='1990-03-03')
 ```
 
-1. This configuration means details about all Pydantic model validations will be recorded. You can also record details about validation failures only, or just metrics; see the [pydantic plugin docs][logfire.PydanticPlugin].
+1. This configuration means details about all Pydantic model validations will be recorded. You can also record details about validation failures only, or just metrics; see the [pydantic plugin docs](../integrations/pydantic.md).
 2. Since we've enabled the Pydantic Plugin, all Pydantic validations will be recorded in Logfire.
 
 Learn more about the [Pydantic Plugin here](../integrations/pydantic.md).
diff --git a/logfire-api/logfire_api/__init__.py b/logfire-api/logfire_api/__init__.py
index 9ad447eab..72a42bcf8 100644
--- a/logfire-api/logfire_api/__init__.py
+++ b/logfire-api/logfire_api/__init__.py
@@ -95,6 +95,8 @@ def decorator(func):
             def instrument_fastapi(self, *args, **kwargs) -> ContextManager[None]:
                 return nullcontext()
 
+            def instrument_pydantic(self, *args, **kwargs) -> None: ...
+
             def instrument_pymongo(self, *args, **kwargs) -> None: ...
 
             def instrument_sqlalchemy(self, *args, **kwargs) -> None: ...
@@ -144,6 +146,7 @@ def shutdown(self, *args, **kwargs) -> None: ...
         log_slow_async_callbacks = DEFAULT_LOGFIRE_INSTANCE.log_slow_async_callbacks
         install_auto_tracing = DEFAULT_LOGFIRE_INSTANCE.install_auto_tracing
         instrument = DEFAULT_LOGFIRE_INSTANCE.instrument
+        instrument_pydantic = DEFAULT_LOGFIRE_INSTANCE.instrument_pydantic
         instrument_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
         instrument_openai = DEFAULT_LOGFIRE_INSTANCE.instrument_openai
         instrument_anthropic = DEFAULT_LOGFIRE_INSTANCE.instrument_anthropic
diff --git a/logfire-api/logfire_api/__init__.pyi b/logfire-api/logfire_api/__init__.pyi
index 8abb59db8..7f28bf2cd 100644
--- a/logfire-api/logfire_api/__init__.pyi
+++ b/logfire-api/logfire_api/__init__.pyi
@@ -11,7 +11,7 @@ from .integrations.structlog import LogfireProcessor as StructlogProcessor
 from .version import VERSION as VERSION
 from logfire.sampling import SamplingOptions as SamplingOptions
 
-__all__ = ['Logfire', 'LogfireSpan', 'LevelName', 'AdvancedOptions', 'ConsoleOptions', 'PydanticPlugin', 'configure', 'span', 'instrument', 'log', 'trace', 'debug', 'notice', 'info', 'warn', 'error', 'exception', 'fatal', 'force_flush', 'log_slow_async_callbacks', 'install_auto_tracing', 'instrument_fastapi', 'instrument_openai', 'instrument_anthropic', 'instrument_asyncpg', 'instrument_httpx', 'instrument_celery', 'instrument_requests', 'instrument_psycopg', 'instrument_django', 'instrument_flask', 'instrument_starlette', 'instrument_aiohttp_client', 'instrument_sqlalchemy', 'instrument_redis', 'instrument_pymongo', 'instrument_mysql', 'instrument_system_metrics', 'AutoTraceModule', 'with_tags', 'with_settings', 'shutdown', 'load_spans_from_file', 'no_auto_trace', 'ScrubMatch', 'ScrubbingOptions', 'VERSION', 'suppress_instrumentation', 'StructlogProcessor', 'LogfireLoggingHandler', 'SamplingOptions', 'MetricsOptions']
+__all__ = ['Logfire', 'LogfireSpan', 'LevelName', 'AdvancedOptions', 'ConsoleOptions', 'PydanticPlugin', 'configure', 'span', 'instrument', 'log', 'trace', 'debug', 'notice', 'info', 'warn', 'error', 'exception', 'fatal', 'force_flush', 'log_slow_async_callbacks', 'install_auto_tracing', 'instrument_pydantic', 'instrument_fastapi', 'instrument_openai', 'instrument_anthropic', 'instrument_asyncpg', 'instrument_httpx', 'instrument_celery', 'instrument_requests', 'instrument_psycopg', 'instrument_django', 'instrument_flask', 'instrument_starlette', 'instrument_aiohttp_client', 'instrument_sqlalchemy', 'instrument_redis', 'instrument_pymongo', 'instrument_mysql', 'instrument_system_metrics', 'AutoTraceModule', 'with_tags', 'with_settings', 'shutdown', 'load_spans_from_file', 'no_auto_trace', 'ScrubMatch', 'ScrubbingOptions', 'VERSION', 'suppress_instrumentation', 'StructlogProcessor', 'LogfireLoggingHandler', 'SamplingOptions', 'MetricsOptions']
 
 DEFAULT_LOGFIRE_INSTANCE = Logfire()
 span = DEFAULT_LOGFIRE_INSTANCE.span
@@ -19,6 +19,7 @@ instrument = DEFAULT_LOGFIRE_INSTANCE.instrument
 force_flush = DEFAULT_LOGFIRE_INSTANCE.force_flush
 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_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
 instrument_openai = DEFAULT_LOGFIRE_INSTANCE.instrument_openai
 instrument_anthropic = DEFAULT_LOGFIRE_INSTANCE.instrument_anthropic
diff --git a/logfire-api/logfire_api/_internal/config.pyi b/logfire-api/logfire_api/_internal/config.pyi
index 5ec1578a5..434326243 100644
--- a/logfire-api/logfire_api/_internal/config.pyi
+++ b/logfire-api/logfire_api/_internal/config.pyi
@@ -17,7 +17,7 @@ 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 PendingSpanProcessor as PendingSpanProcessor, ProxyTracerProvider as ProxyTracerProvider
-from .utils import UnexpectedResponse as UnexpectedResponse, ensure_data_dir_exists as ensure_data_dir_exists, get_version as get_version, read_toml_file as read_toml_file, suppress_instrumentation as suppress_instrumentation
+from .utils import SeededRandomIdGenerator as SeededRandomIdGenerator, UnexpectedResponse as UnexpectedResponse, ensure_data_dir_exists as ensure_data_dir_exists, read_toml_file as read_toml_file, suppress_instrumentation as suppress_instrumentation
 from _typeshed import Incomplete
 from dataclasses import dataclass
 from functools import cached_property
@@ -59,7 +59,10 @@ class AdvancedOptions:
 
 @dataclass
 class PydanticPlugin:
-    """Options for the Pydantic plugin."""
+    """Options for the Pydantic plugin.
+
+    This class is deprecated for external use. Use `logfire.instrument_pydantic()` instead.
+    """
     record: PydanticPluginRecordValues = ...
     include: set[str] = ...
     exclude: set[str] = ...
@@ -74,7 +77,7 @@ class MetricsOptions:
 
 class DeprecatedKwargs(TypedDict): ...
 
-def configure(*, send_to_logfire: bool | Literal['if-token-present'] | None = None, token: str | None = None, service_name: str | None = None, service_version: str | 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, pydantic_plugin: PydanticPlugin | None = None, scrubbing: ScrubbingOptions | Literal[False] | None = None, inspect_arguments: bool | None = None, sampling: SamplingOptions | None = None, advanced: AdvancedOptions | None = None, **deprecated_kwargs: Unpack[DeprecatedKwargs]) -> None:
+def configure(*, send_to_logfire: bool | Literal['if-token-present'] | None = None, token: str | None = None, service_name: str | None = None, service_version: str | 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, advanced: AdvancedOptions | None = None, **deprecated_kwargs: Unpack[DeprecatedKwargs]) -> None:
     """Configure the logfire SDK.
 
     Args:
@@ -94,8 +97,6 @@ def configure(*, send_to_logfire: bool | Literal['if-token-present'] | None = No
         additional_span_processors: Span processors to use in addition to the default processor which exports spans to Logfire's API.
         metrics: Set to `False` to disable sending all metrics,
             or provide a `MetricsOptions` object to configure metrics, e.g. additional metric readers.
-        pydantic_plugin: Configuration for the Pydantic plugin. If `None` uses the `LOGFIRE_PYDANTIC_PLUGIN_*` environment
-            variables, otherwise defaults to `PydanticPlugin(record='off')`.
         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).
@@ -123,21 +124,20 @@ class _LogfireConfigData:
     console: ConsoleOptions | Literal[False] | None
     data_dir: Path
     additional_span_processors: Sequence[SpanProcessor] | None
-    pydantic_plugin: PydanticPlugin
     scrubbing: ScrubbingOptions | Literal[False]
     inspect_arguments: bool
     sampling: SamplingOptions
     advanced: AdvancedOptions
 
 class LogfireConfig(_LogfireConfigData):
-    def __init__(self, send_to_logfire: bool | None = None, token: str | None = None, service_name: str | None = None, service_version: str | None = None, console: ConsoleOptions | Literal[False] | None = None, config_dir: Path | None = None, data_dir: Path | None = None, additional_span_processors: Sequence[SpanProcessor] | None = None, metrics: MetricsOptions | Literal[False] | None = None, pydantic_plugin: PydanticPlugin | None = None, scrubbing: ScrubbingOptions | Literal[False] | None = None, inspect_arguments: bool | None = None, sampling: SamplingOptions | None = None, advanced: AdvancedOptions | None = None) -> None:
+    def __init__(self, send_to_logfire: bool | None = None, token: str | None = None, service_name: str | None = None, service_version: str | None = None, console: ConsoleOptions | Literal[False] | None = None, config_dir: Path | None = None, data_dir: Path | None = None, additional_span_processors: Sequence[SpanProcessor] | None = None, metrics: MetricsOptions | Literal[False] | None = None, scrubbing: ScrubbingOptions | Literal[False] | None = None, inspect_arguments: bool | None = None, sampling: SamplingOptions | None = None, advanced: AdvancedOptions | None = None) -> None:
         """Create a new LogfireConfig.
 
         Users should never need to call this directly, instead use `logfire.configure`.
 
         See `_LogfireConfigData` for parameter documentation.
         """
-    def configure(self, send_to_logfire: bool | Literal['if-token-present'] | None, token: str | None, service_name: str | None, service_version: str | None, console: ConsoleOptions | Literal[False] | None, config_dir: Path | None, data_dir: Path | None, additional_span_processors: Sequence[SpanProcessor] | None, metrics: MetricsOptions | Literal[False] | None, pydantic_plugin: PydanticPlugin | None, scrubbing: ScrubbingOptions | Literal[False] | None, inspect_arguments: bool | None, sampling: SamplingOptions | None, advanced: AdvancedOptions | None) -> None: ...
+    def configure(self, send_to_logfire: bool | Literal['if-token-present'] | None, token: str | None, service_name: str | None, service_version: str | None, console: ConsoleOptions | Literal[False] | None, config_dir: Path | None, data_dir: Path | None, additional_span_processors: Sequence[SpanProcessor] | None, metrics: MetricsOptions | Literal[False] | None, scrubbing: ScrubbingOptions | Literal[False] | None, inspect_arguments: bool | None, sampling: SamplingOptions | None, advanced: AdvancedOptions | None) -> None: ...
     def initialize(self) -> ProxyTracerProvider:
         """Configure internals to start exporting traces and metrics."""
     def force_flush(self, timeout_millis: int = 30000) -> bool:
diff --git a/logfire-api/logfire_api/_internal/config_params.pyi b/logfire-api/logfire_api/_internal/config_params.pyi
index af89b67a9..526c4dd7a 100644
--- a/logfire-api/logfire_api/_internal/config_params.pyi
+++ b/logfire-api/logfire_api/_internal/config_params.pyi
@@ -75,5 +75,3 @@ class ParamManager:
         """
     @cached_property
     def pydantic_plugin(self): ...
-
-def default_param_manager(): ...
diff --git a/logfire-api/logfire_api/_internal/main.pyi b/logfire-api/logfire_api/_internal/main.pyi
index 24b792d9e..50b41b23e 100644
--- a/logfire-api/logfire_api/_internal/main.pyi
+++ b/logfire-api/logfire_api/_internal/main.pyi
@@ -5,6 +5,7 @@ from . import async_ as async_
 from ..version import VERSION as VERSION
 from .auto_trace import AutoTraceModule as AutoTraceModule, install_auto_tracing as install_auto_tracing
 from .config import GLOBAL_CONFIG as GLOBAL_CONFIG, LogfireConfig as LogfireConfig, OPEN_SPANS as OPEN_SPANS
+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, ATTRIBUTES_VALIDATION_ERROR_KEY as ATTRIBUTES_VALIDATION_ERROR_KEY, DISABLE_CONSOLE_KEY as DISABLE_CONSOLE_KEY, LEVEL_NUMBERS as LEVEL_NUMBERS, LevelName as LevelName, NULL_ARGS_KEY as NULL_ARGS_KEY, 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 .instrument import LogfireArgs as LogfireArgs, instrument as instrument
@@ -24,7 +25,7 @@ from .json_schema import JsonSchemaProperties as JsonSchemaProperties, attribute
 from .metrics import ProxyMeterProvider as ProxyMeterProvider
 from .stack_info import get_user_stack_info as get_user_stack_info
 from .tracer import ProxyTracerProvider as ProxyTracerProvider
-from .utils import SysExcInfo as SysExcInfo, handle_internal_errors as handle_internal_errors, log_internal_error as log_internal_error, uniquify_sequence as uniquify_sequence
+from .utils import SysExcInfo as SysExcInfo, get_version as get_version, handle_internal_errors as handle_internal_errors, log_internal_error as log_internal_error, uniquify_sequence as uniquify_sequence
 from django.http import HttpRequest as HttpRequest, HttpResponse as HttpResponse
 from fastapi import FastAPI
 from flask.app import Flask
@@ -367,6 +368,24 @@ class Logfire:
                 modules in `sys.modules` (i.e. modules that have already been imported) match the modules to trace.
                 Set to `'warn'` to issue a warning instead, or `'ignore'` to skip the check.
         """
+    def instrument_pydantic(self, record: PydanticPluginRecordValues = 'all', include: Iterable[str] = (), exclude: Iterable[str] = ()):
+        """Instrument Pydantic model validations.
+
+        This must be called before defining and importing the model classes you want to instrument.
+        See the [Pydantic integration guide](https://logfire.pydantic.dev/docs/integrations/pydantic/) for more info.
+
+        Args:
+            record: The record mode for the Pydantic plugin. It can be one of the following values:
+
+                - `all`: Send traces and metrics for all events. This is default value.
+                - `failure`: Send metrics for all validations and traces only for validation failures.
+                - `metrics`: Send only metrics.
+                - `off`: Disable instrumentation.
+            include:
+                By default, third party modules are not instrumented. This option allows you to include specific modules.
+            exclude:
+                Exclude specific modules from instrumentation.
+        """
     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, use_opentelemetry_instrumentation: bool = True, excluded_urls: str | Iterable[str] | None = None, record_send_receive: bool = False, **opentelemetry_kwargs: Any) -> ContextManager[None]:
         """Instrument a FastAPI app so that spans and logs are automatically created for each request.
 
diff --git a/logfire-api/logfire_api/_internal/utils.pyi b/logfire-api/logfire_api/_internal/utils.pyi
index 7e0bcd6c0..127f7193b 100644
--- a/logfire-api/logfire_api/_internal/utils.pyi
+++ b/logfire-api/logfire_api/_internal/utils.pyi
@@ -1,9 +1,11 @@
 from _typeshed import Incomplete
 from collections.abc import Generator
+from dataclasses import dataclass
 from logfire._internal.stack_info import is_user_code as is_user_code
 from opentelemetry import trace as trace_api
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import Event as Event, ReadableSpan
+from opentelemetry.sdk.trace.id_generator import IdGenerator
 from opentelemetry.sdk.util.instrumentation import InstrumentationScope
 from opentelemetry.trace.status import Status
 from opentelemetry.util import types as otel_types
@@ -88,3 +90,20 @@ def log_internal_error() -> None: ...
 def handle_internal_errors() -> Generator[None, None, None]: ...
 def maybe_capture_server_headers(capture: bool): ...
 def is_asgi_send_receive_span_name(name: str) -> bool: ...
+
+@dataclass(repr=True)
+class SeededRandomIdGenerator(IdGenerator):
+    """Generate random span/trace IDs from a seed for deterministic tests.
+
+    Similar to RandomIdGenerator from OpenTelemetry, but with a seed.
+    Set the seed to None for non-deterministic randomness.
+    In that case the difference from RandomIdGenerator is that it's not affected by `random.seed(...)`.
+
+    Trace IDs are 128-bit integers.
+    Span IDs are 64-bit integers.
+    """
+    seed: int | None = ...
+    random = ...
+    def __post_init__(self) -> None: ...
+    def generate_span_id(self) -> int: ...
+    def generate_trace_id(self) -> int: ...
diff --git a/logfire-api/logfire_api/integrations/pydantic.pyi b/logfire-api/logfire_api/integrations/pydantic.pyi
index ef163fa1e..513a702ed 100644
--- a/logfire-api/logfire_api/integrations/pydantic.pyi
+++ b/logfire-api/logfire_api/integrations/pydantic.pyi
@@ -1,5 +1,4 @@
 from .._internal.config import GLOBAL_CONFIG as GLOBAL_CONFIG, PydanticPlugin as PydanticPlugin
-from .._internal.config_params import default_param_manager as default_param_manager
 from .._internal.utils import get_version as get_version
 from _typeshed import Incomplete
 from dataclasses import dataclass
@@ -92,5 +91,10 @@ class LogfirePydanticPlugin:
 plugin: Incomplete
 IGNORED_MODULES: tuple[str, ...]
 IGNORED_MODULE_PREFIXES: tuple[str, ...]
+
+def get_pydantic_plugin_config() -> PydanticPlugin:
+    """Get the Pydantic plugin config."""
+def set_pydantic_plugin_config(plugin_config: PydanticPlugin | None) -> None:
+    """Set the pydantic plugin config."""
 P = ParamSpec('P')
 R = TypeVar('R')
diff --git a/logfire/__init__.py b/logfire/__init__.py
index 4acb351d5..1822cfae4 100644
--- a/logfire/__init__.py
+++ b/logfire/__init__.py
@@ -30,6 +30,7 @@
 force_flush = DEFAULT_LOGFIRE_INSTANCE.force_flush
 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_fastapi = DEFAULT_LOGFIRE_INSTANCE.instrument_fastapi
 instrument_openai = DEFAULT_LOGFIRE_INSTANCE.instrument_openai
 instrument_anthropic = DEFAULT_LOGFIRE_INSTANCE.instrument_anthropic
@@ -108,6 +109,7 @@ def loguru_handler() -> dict[str, Any]:
     'force_flush',
     'log_slow_async_callbacks',
     'install_auto_tracing',
+    'instrument_pydantic',
     'instrument_fastapi',
     'instrument_openai',
     'instrument_anthropic',
diff --git a/logfire/_internal/config.py b/logfire/_internal/config.py
index fc2a4c689..6b9820705 100644
--- a/logfire/_internal/config.py
+++ b/logfire/_internal/config.py
@@ -87,7 +87,6 @@
     SeededRandomIdGenerator,
     UnexpectedResponse,
     ensure_data_dir_exists,
-    get_version,
     read_toml_file,
     suppress_instrumentation,
 )
@@ -158,7 +157,10 @@ class AdvancedOptions:
 
 @dataclass
 class PydanticPlugin:
-    """Options for the Pydantic plugin."""
+    """Options for the Pydantic plugin.
+
+    This class is deprecated for external use. Use `logfire.instrument_pydantic()` instead.
+    """
 
     record: PydanticPluginRecordValues = 'off'
     """The record mode for the Pydantic plugin.
@@ -203,7 +205,6 @@ def configure(  # noqa: D417
     data_dir: Path | str | None = None,
     additional_span_processors: Sequence[SpanProcessor] | None = None,
     metrics: MetricsOptions | Literal[False] | None = None,
-    pydantic_plugin: PydanticPlugin | None = None,
     scrubbing: ScrubbingOptions | Literal[False] | None = None,
     inspect_arguments: bool | None = None,
     sampling: SamplingOptions | None = None,
@@ -229,8 +230,6 @@ def configure(  # noqa: D417
         additional_span_processors: Span processors to use in addition to the default processor which exports spans to Logfire's API.
         metrics: Set to `False` to disable sending all metrics,
             or provide a `MetricsOptions` object to configure metrics, e.g. additional metric readers.
-        pydantic_plugin: Configuration for the Pydantic plugin. If `None` uses the `LOGFIRE_PYDANTIC_PLUGIN_*` environment
-            variables, otherwise defaults to `PydanticPlugin(record='off')`.
         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).
@@ -338,6 +337,16 @@ def configure(  # noqa: D417
         )
         metrics = MetricsOptions(additional_readers=additional_metric_readers)
 
+    pydantic_plugin: Any = deprecated_kwargs.pop('pydantic_plugin', None)  # type: ignore
+    if pydantic_plugin is not None:
+        warnings.warn(
+            'The `pydantic_plugin` argument is deprecated. Use `logfire.instrument_pydantic()` instead.',
+            DeprecationWarning,
+        )
+        from logfire.integrations.pydantic import set_pydantic_plugin_config
+
+        set_pydantic_plugin_config(pydantic_plugin)
+
     if deprecated_kwargs:
         raise TypeError(f'configure() got unexpected keyword arguments: {", ".join(deprecated_kwargs)}')
 
@@ -351,7 +360,6 @@ def configure(  # noqa: D417
         config_dir=Path(config_dir) if config_dir else None,
         data_dir=Path(data_dir) if data_dir else None,
         additional_span_processors=additional_span_processors,
-        pydantic_plugin=pydantic_plugin,
         scrubbing=scrubbing,
         inspect_arguments=inspect_arguments,
         sampling=sampling,
@@ -399,9 +407,6 @@ class _LogfireConfigData:
     additional_span_processors: Sequence[SpanProcessor] | None
     """Additional span processors"""
 
-    pydantic_plugin: PydanticPlugin
-    """Options for the Pydantic plugin"""
-
     scrubbing: ScrubbingOptions | Literal[False]
     """Options for redacting sensitive data, or False to disable."""
 
@@ -428,14 +433,13 @@ def _load_configuration(
         data_dir: Path | None,
         additional_span_processors: Sequence[SpanProcessor] | None,
         metrics: MetricsOptions | Literal[False] | None,
-        pydantic_plugin: PydanticPlugin | None,
         scrubbing: ScrubbingOptions | Literal[False] | None,
         inspect_arguments: bool | None,
         sampling: SamplingOptions | None,
         advanced: AdvancedOptions | None,
     ) -> None:
         """Merge the given parameters with the environment variables file configurations."""
-        param_manager = ParamManager.create(config_dir)
+        self.param_manager = param_manager = ParamManager.create(config_dir)
 
         self.send_to_logfire = param_manager.load_param('send_to_logfire', send_to_logfire)
         self.token = param_manager.load_param('token', token)
@@ -477,16 +481,6 @@ def _load_configuration(
                 show_project_link=param_manager.load_param('console_show_project_link'),
             )
 
-        if isinstance(pydantic_plugin, dict):
-            # This is particularly for deserializing from a dict as in executors.py
-            pydantic_plugin = PydanticPlugin(**pydantic_plugin)  # type: ignore
-        self.pydantic_plugin = pydantic_plugin or param_manager.pydantic_plugin
-        if self.pydantic_plugin.record != 'off':
-            import pydantic
-
-            if get_version(pydantic.__version__) < get_version('2.5.0'):  # pragma: no cover
-                raise RuntimeError('The Pydantic plugin requires Pydantic 2.5.0 or newer.')
-
         if isinstance(sampling, dict):
             # This is particularly for deserializing from a dict as in executors.py
             sampling = SamplingOptions(**sampling)  # type: ignore
@@ -530,7 +524,6 @@ def __init__(
         data_dir: Path | None = None,
         additional_span_processors: Sequence[SpanProcessor] | None = None,
         metrics: MetricsOptions | Literal[False] | None = None,
-        pydantic_plugin: PydanticPlugin | None = None,
         scrubbing: ScrubbingOptions | Literal[False] | None = None,
         inspect_arguments: bool | None = None,
         sampling: SamplingOptions | None = None,
@@ -554,7 +547,6 @@ def __init__(
             data_dir=data_dir,
             additional_span_processors=additional_span_processors,
             metrics=metrics,
-            pydantic_plugin=pydantic_plugin,
             scrubbing=scrubbing,
             inspect_arguments=inspect_arguments,
             sampling=sampling,
@@ -582,7 +574,6 @@ def configure(
         data_dir: Path | None,
         additional_span_processors: Sequence[SpanProcessor] | None,
         metrics: MetricsOptions | Literal[False] | None,
-        pydantic_plugin: PydanticPlugin | None,
         scrubbing: ScrubbingOptions | Literal[False] | None,
         inspect_arguments: bool | None,
         sampling: SamplingOptions | None,
@@ -600,7 +591,6 @@ def configure(
                 data_dir,
                 additional_span_processors,
                 metrics,
-                pydantic_plugin,
                 scrubbing,
                 inspect_arguments,
                 sampling,
diff --git a/logfire/_internal/config_params.py b/logfire/_internal/config_params.py
index 25f844756..66ba1c4f3 100644
--- a/logfire/_internal/config_params.py
+++ b/logfire/_internal/config_params.py
@@ -3,7 +3,7 @@
 import os
 import sys
 from dataclasses import dataclass
-from functools import cached_property, lru_cache
+from functools import cached_property
 from pathlib import Path
 from typing import Any, Callable, Literal, Set, TypeVar
 
@@ -194,11 +194,6 @@ def _cast(self, value: Any, name: str, tp: type[T]) -> T | None:
         raise RuntimeError(f'Unexpected type {tp}')  # pragma: no cover
 
 
-@lru_cache
-def default_param_manager():
-    return ParamManager.create()
-
-
 def _check_literal(value: Any, name: str, tp: type[T]) -> T | None:
     if value is None:  # pragma: no cover
         return None
diff --git a/logfire/_internal/main.py b/logfire/_internal/main.py
index e1f2f4e24..151c5f7a2 100644
--- a/logfire/_internal/main.py
+++ b/logfire/_internal/main.py
@@ -21,6 +21,7 @@
 from . import async_
 from .auto_trace import AutoTraceModule, install_auto_tracing
 from .config import GLOBAL_CONFIG, OPEN_SPANS, LogfireConfig
+from .config_params import PydanticPluginRecordValues
 from .constants import (
     ATTRIBUTES_JSON_SCHEMA_KEY,
     ATTRIBUTES_LOG_LEVEL_NUM_KEY,
@@ -49,7 +50,7 @@
 from .metrics import ProxyMeterProvider
 from .stack_info import get_user_stack_info
 from .tracer import ProxyTracerProvider
-from .utils import handle_internal_errors, log_internal_error, uniquify_sequence
+from .utils import get_version, handle_internal_errors, log_internal_error, uniquify_sequence
 
 if TYPE_CHECKING:
     import anthropic
@@ -802,6 +803,54 @@ def install_auto_tracing(
     def _warn_if_not_initialized_for_instrumentation(self):
         self.config.warn_if_not_initialized('Instrumentation will have no effect')
 
+    def instrument_pydantic(
+        self,
+        record: PydanticPluginRecordValues = 'all',
+        include: Iterable[str] = (),
+        exclude: Iterable[str] = (),
+    ):
+        """Instrument Pydantic model validations.
+
+        This must be called before defining and importing the model classes you want to instrument.
+        See the [Pydantic integration guide](https://logfire.pydantic.dev/docs/integrations/pydantic/) for more info.
+
+        Args:
+            record: The record mode for the Pydantic plugin. It can be one of the following values:
+
+                - `all`: Send traces and metrics for all events. This is default value.
+                - `failure`: Send metrics for all validations and traces only for validation failures.
+                - `metrics`: Send only metrics.
+                - `off`: Disable instrumentation.
+            include:
+                By default, third party modules are not instrumented. This option allows you to include specific modules.
+            exclude:
+                Exclude specific modules from instrumentation.
+        """
+        # Note that unlike most instrument_* methods, we intentionally don't call
+        # _warn_if_not_initialized_for_instrumentation, because this method needs to be called early.
+
+        if record != 'off':
+            import pydantic
+
+            if get_version(pydantic.__version__) < get_version('2.5.0'):  # pragma: no cover
+                raise RuntimeError('The Pydantic plugin requires Pydantic 2.5.0 or newer.')
+
+        from logfire.integrations.pydantic import PydanticPlugin, set_pydantic_plugin_config
+
+        if isinstance(include, str):
+            include = {include}
+
+        if isinstance(exclude, str):
+            exclude = {exclude}
+
+        set_pydantic_plugin_config(
+            PydanticPlugin(
+                record=record,
+                include=set(include),
+                exclude=set(exclude),
+            )
+        )
+
     def instrument_fastapi(
         self,
         app: FastAPI,
diff --git a/logfire/integrations/pydantic.py b/logfire/integrations/pydantic.py
index c54ebe279..4cd5e3819 100644
--- a/logfire/integrations/pydantic.py
+++ b/logfire/integrations/pydantic.py
@@ -17,7 +17,6 @@
 from logfire import LogfireSpan
 
 from .._internal.config import GLOBAL_CONFIG, PydanticPlugin
-from .._internal.config_params import default_param_manager
 from .._internal.utils import get_version
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -25,7 +24,6 @@
     from pydantic.plugin import SchemaKind, SchemaTypePath
     from pydantic_core import CoreConfig, CoreSchema
 
-
 METER = GLOBAL_CONFIG._meter_provider.get_meter('logfire.pydantic')  # type: ignore
 validation_counter = METER.create_counter('pydantic.validations')
 
@@ -343,7 +341,7 @@ def new_schema_validator(
             if logfire_settings and 'record' in logfire_settings:
                 record = logfire_settings['record']
             else:
-                record = _pydantic_plugin_config().record
+                record = get_pydantic_plugin_config().record
 
             if record == 'off':
                 return None, None, None
@@ -365,17 +363,26 @@ def new_schema_validator(
 IGNORED_MODULES: tuple[str, ...] = 'fastapi', 'logfire_backend', 'fastui'
 IGNORED_MODULE_PREFIXES: tuple[str, ...] = tuple(f'{module}.' for module in IGNORED_MODULES)
 
+_pydantic_plugin_config_value: PydanticPlugin | None = None
+
 
-def _pydantic_plugin_config() -> PydanticPlugin:
-    if GLOBAL_CONFIG._initialized:  # type: ignore
-        return GLOBAL_CONFIG.pydantic_plugin
+def get_pydantic_plugin_config() -> PydanticPlugin:
+    """Get the Pydantic plugin config."""
+    if _pydantic_plugin_config_value is not None:
+        return _pydantic_plugin_config_value
     else:
-        return default_param_manager().pydantic_plugin
+        return GLOBAL_CONFIG.param_manager.pydantic_plugin
+
+
+def set_pydantic_plugin_config(plugin_config: PydanticPlugin | None) -> None:
+    """Set the pydantic plugin config."""
+    global _pydantic_plugin_config_value
+    _pydantic_plugin_config_value = plugin_config
 
 
 def _include_model(schema_type_path: SchemaTypePath) -> bool:
     """Check whether a model should be instrumented."""
-    config = _pydantic_plugin_config()
+    config = get_pydantic_plugin_config()
     include = config.include
     exclude = config.exclude
 
diff --git a/tests/conftest.py b/tests/conftest.py
index f3c2ccc39..ff51eebea 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -15,6 +15,7 @@
 import logfire
 from logfire import configure
 from logfire._internal.config import METRICS_PREFERRED_TEMPORALITY
+from logfire.integrations.pydantic import set_pydantic_plugin_config
 from logfire.testing import IncrementalIdGenerator, TestExporter, TimeGenerator
 
 # Emit both new and old semantic convention attribute names
@@ -26,6 +27,11 @@ def anyio_backend():
     return 'asyncio'
 
 
+@pytest.fixture(autouse=True)
+def reset_pydantic_plugin_config():
+    set_pydantic_plugin_config(None)
+
+
 @pytest.fixture
 def id_generator() -> IncrementalIdGenerator:
     return IncrementalIdGenerator()
diff --git a/tests/test_configure.py b/tests/test_configure.py
index a236ced50..84ebb6b35 100644
--- a/tests/test_configure.py
+++ b/tests/test_configure.py
@@ -51,6 +51,7 @@
 from logfire._internal.integrations.executors import deserialize_config, serialize_config
 from logfire._internal.tracer import PendingSpanProcessor
 from logfire.exceptions import LogfireConfigError
+from logfire.integrations.pydantic import get_pydantic_plugin_config
 from logfire.testing import TestExporter
 
 
@@ -415,29 +416,54 @@ def test_propagate_config_to_tags(exporter: TestExporter) -> None:
     )
 
 
+def fresh_pydantic_plugin():
+    GLOBAL_CONFIG.param_manager.__dict__.pop('pydantic_plugin', None)  # reset the cached_property
+    return get_pydantic_plugin_config()
+
+
+def test_pydantic_plugin_include_exclude_strings():
+    logfire.instrument_pydantic(include='inc', exclude='exc')
+    assert fresh_pydantic_plugin().include == {'inc'}
+    assert fresh_pydantic_plugin().exclude == {'exc'}
+
+
+def test_deprecated_configure_pydantic_plugin(config_kwargs: dict[str, Any]):
+    assert fresh_pydantic_plugin().record == 'off'
+
+    with pytest.warns(DeprecationWarning) as warnings:
+        logfire.configure(**config_kwargs, pydantic_plugin=logfire.PydanticPlugin(record='all'))  # type: ignore
+
+    assert fresh_pydantic_plugin().record == 'all'
+
+    assert len(warnings) == 1
+    assert str(warnings[0].message) == snapshot(
+        'The `pydantic_plugin` argument is deprecated. Use `logfire.instrument_pydantic()` instead.'
+    )
+
+
 def test_read_config_from_environment_variables() -> None:
-    assert LogfireConfig().pydantic_plugin.record == 'off'
+    assert fresh_pydantic_plugin().record == 'off'
 
     with patch.dict(os.environ, {'LOGFIRE_PYDANTIC_PLUGIN_RECORD': 'all'}):
-        assert LogfireConfig().pydantic_plugin.record == 'all'
+        assert fresh_pydantic_plugin().record == 'all'
     with patch.dict(os.environ, {'LOGFIRE_PYDANTIC_PLUGIN_RECORD': 'test'}):
         with pytest.raises(
             LogfireConfigError,
             match="Expected pydantic_plugin_record to be one of \\('off', 'all', 'failure', 'metrics'\\), got 'test'",
         ):
-            LogfireConfig()
+            fresh_pydantic_plugin()
 
-    assert LogfireConfig().pydantic_plugin.include == set()
+    assert fresh_pydantic_plugin().include == set()
     with patch.dict(os.environ, {'LOGFIRE_PYDANTIC_PLUGIN_INCLUDE': 'test'}):
-        assert LogfireConfig().pydantic_plugin.include == {'test'}
+        assert fresh_pydantic_plugin().include == {'test'}
     with patch.dict(os.environ, {'LOGFIRE_PYDANTIC_PLUGIN_INCLUDE': 'test1, test2'}):
-        assert LogfireConfig().pydantic_plugin.include == {'test1', 'test2'}
+        assert fresh_pydantic_plugin().include == {'test1', 'test2'}
 
-    assert LogfireConfig().pydantic_plugin.exclude == set()
+    assert fresh_pydantic_plugin().exclude == set()
     with patch.dict(os.environ, {'LOGFIRE_PYDANTIC_PLUGIN_EXCLUDE': 'test'}):
-        assert LogfireConfig().pydantic_plugin.exclude == {'test'}
+        assert fresh_pydantic_plugin().exclude == {'test'}
     with patch.dict(os.environ, {'LOGFIRE_PYDANTIC_PLUGIN_EXCLUDE': 'test1, test2'}):
-        assert LogfireConfig().pydantic_plugin.exclude == {'test1', 'test2'}
+        assert fresh_pydantic_plugin().exclude == {'test1', 'test2'}
 
 
 def test_read_config_from_pyproject_toml(tmp_path: Path) -> None:
@@ -465,9 +491,9 @@ def test_read_config_from_pyproject_toml(tmp_path: Path) -> None:
     assert GLOBAL_CONFIG.console.colors == 'never'
     assert GLOBAL_CONFIG.console.include_timestamps is False
     assert GLOBAL_CONFIG.data_dir == tmp_path
-    assert GLOBAL_CONFIG.pydantic_plugin.record == 'metrics'
-    assert GLOBAL_CONFIG.pydantic_plugin.include == {'test1', 'test2'}
-    assert GLOBAL_CONFIG.pydantic_plugin.exclude == {'test3', 'test4'}
+    assert fresh_pydantic_plugin().record == 'metrics'
+    assert fresh_pydantic_plugin().include == {'test1', 'test2'}
+    assert fresh_pydantic_plugin().exclude == {'test3', 'test4'}
     assert GLOBAL_CONFIG.sampling.head == 0.123
 
 
@@ -794,7 +820,6 @@ def test_config_serializable():
     """
     logfire.configure(
         send_to_logfire=False,
-        pydantic_plugin=logfire.PydanticPlugin(record='all'),
         console=logfire.ConsoleOptions(verbose=True),
         sampling=logfire.SamplingOptions(),
         scrubbing=logfire.ScrubbingOptions(),
@@ -804,7 +829,7 @@ def test_config_serializable():
         # Check that the full set of dataclass fields is known.
         # If a new field appears here, make sure it gets deserialized properly in configure, and tested here.
         assert dataclasses.is_dataclass(getattr(GLOBAL_CONFIG, field.name)) == (
-            field.name in ['pydantic_plugin', 'console', 'sampling', 'scrubbing', 'advanced']
+            field.name in ['console', 'sampling', 'scrubbing', 'advanced']
         )
 
     serialized = serialize_config()
@@ -820,7 +845,6 @@ def normalize(s: dict[str, Any]) -> dict[str, Any]:
 
     assert normalize(serialized) == normalize(serialized2)
 
-    assert isinstance(GLOBAL_CONFIG.pydantic_plugin, logfire.PydanticPlugin)
     assert isinstance(GLOBAL_CONFIG.console, logfire.ConsoleOptions)
     assert isinstance(GLOBAL_CONFIG.sampling, logfire.SamplingOptions)
     assert isinstance(GLOBAL_CONFIG.scrubbing, logfire.ScrubbingOptions)
diff --git a/tests/test_pydantic_plugin.py b/tests/test_pydantic_plugin.py
index f7f490211..31f4e9a2f 100644
--- a/tests/test_pydantic_plugin.py
+++ b/tests/test_pydantic_plugin.py
@@ -20,9 +20,12 @@
 from typing_extensions import Annotated
 
 import logfire
-from logfire._internal.config import GLOBAL_CONFIG, PydanticPlugin
-from logfire._internal.config_params import default_param_manager
-from logfire.integrations.pydantic import LogfirePydanticPlugin, get_schema_name
+import logfire.integrations.pydantic
+from logfire._internal.config import GLOBAL_CONFIG
+from logfire.integrations.pydantic import (
+    LogfirePydanticPlugin,
+    get_schema_name,
+)
 from logfire.testing import SeededRandomIdGenerator, TestExporter
 from tests.test_metrics import get_collected_metrics
 
@@ -48,9 +51,9 @@ def test_check_plugin_installed():
 def test_disable_logfire_pydantic_plugin() -> None:
     logfire.configure(
         send_to_logfire=False,
-        pydantic_plugin=PydanticPlugin(record='off'),
         metrics=logfire.MetricsOptions(additional_readers=[InMemoryMetricReader()]),
     )
+    logfire.instrument_pydantic(record='off')
     plugin = LogfirePydanticPlugin()
     assert plugin.new_schema_validator(
         core_schema.int_schema(), None, SchemaTypePath(module='', name=''), 'BaseModel', None, {}
@@ -79,7 +82,7 @@ class MyModel(BaseModel, plugin_settings={'logfire': {'record': 'off'}}):
 
 
 def test_pydantic_plugin_settings_record_override_pydantic_plugin_record(exporter: TestExporter) -> None:
-    GLOBAL_CONFIG.pydantic_plugin.record = 'all'
+    logfire.instrument_pydantic()
 
     class MyModel(BaseModel, plugin_settings={'logfire': {'record': 'off'}}):
         x: int
@@ -120,9 +123,9 @@ def test_logfire_plugin_include_exclude_models(
 ) -> None:
     logfire.configure(
         send_to_logfire=False,
-        pydantic_plugin=PydanticPlugin(record='all', include=include, exclude=exclude),
         metrics=logfire.MetricsOptions(additional_readers=[InMemoryMetricReader()]),
     )
+    logfire.instrument_pydantic(record='all', include=include, exclude=exclude)
     plugin = LogfirePydanticPlugin()
 
     result = plugin.new_schema_validator(
@@ -700,7 +703,7 @@ class MyModel(
     assert len(exporter.exported_spans_as_dict()) == 6
 
     # TODO(Marcelo): Why are those lines not being reached?
-    span = exporter.exported_spans_as_dict()[0]  #  pragma: no cover
+    span = exporter.exported_spans_as_dict()[0]  # pragma: no cover
     assert span['attributes']['logfire.tags'] == ('test_tag',)  # pragma: no cover
 
 
@@ -1094,8 +1097,6 @@ def test_record_all_env_var(exporter: TestExporter) -> None:
     GLOBAL_CONFIG._initialized = False  # type: ignore
 
     with patch.dict(os.environ, {'LOGFIRE_PYDANTIC_PLUGIN_RECORD': 'all'}):
-        default_param_manager.cache_clear()
-
         # This model should be instrumented even though logfire.configure() hasn't been called
         # because of the LOGFIRE_PYDANTIC_PLUGIN_RECORD env var.
         class MyModel(BaseModel):
@@ -1143,7 +1144,6 @@ def test_record_failure_env_var(exporter: TestExporter) -> None:
     GLOBAL_CONFIG._initialized = False  # type: ignore
 
     with patch.dict(os.environ, {'LOGFIRE_PYDANTIC_PLUGIN_RECORD': 'failure'}):
-        default_param_manager.cache_clear()
 
         class MyModel(BaseModel):
             x: int
@@ -1188,7 +1188,6 @@ def test_record_metrics_env_var(metrics_reader: InMemoryMetricReader) -> None:
     GLOBAL_CONFIG._initialized = False  # type: ignore
 
     with patch.dict(os.environ, {'LOGFIRE_PYDANTIC_PLUGIN_RECORD': 'metrics'}):
-        default_param_manager.cache_clear()
 
         class MyModel(BaseModel):
             x: int