grpc-client-kit 0.1.2__tar.gz → 0.3.0__tar.gz

{grpc_client_kit-0.1.2 → grpc_client_kit-0.3.0}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.3.0](https://github.com/bedrock-python/grpc-client-kit/compare/grpc-client-kit-v0.2.0...grpc-client-kit-v0.3.0) (2026-09-14)
+
+
+### Features
+
+* Prometheus collector for the metrics protocol and Dishka providers for the client lifecycle ([6dfdb44](https://github.com/bedrock-python/grpc-client-kit/commit/6dfdb44f2f818c6036f465844c96c2151ee511db)), closes [#28](https://github.com/bedrock-python/grpc-client-kit/issues/28)
+
+## [0.2.0](https://github.com/bedrock-python/grpc-client-kit/compare/grpc-client-kit-v0.1.2...grpc-client-kit-v0.2.0) (2026-09-14)
+
+
+### Features
+
+* settings models for the environment, mirroring the dataclasses ([edffb5f](https://github.com/bedrock-python/grpc-client-kit/commit/edffb5fdcf934cecd5788a99e37064133383d9cd))
+
 ## [0.1.2](https://github.com/bedrock-python/grpc-client-kit/compare/grpc-client-kit-v0.1.1...grpc-client-kit-v0.1.2) (2026-09-07)
 
 

{grpc_client_kit-0.1.2 → grpc_client_kit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: grpc-client-kit
-Version: 0.1.2
+Version: 0.3.0
 Summary: Batteries-optional async gRPC client toolkit (channel pool, load balancing, health checking, streaming-aware interceptors, observability)
 Project-URL: Repository, https://github.com/bedrock-python/grpc-client-kit
 Project-URL: Documentation, https://bedrock-python.github.io/grpc-client-kit/
@@ -223,11 +223,15 @@ Requires-Python: >=3.12
 Requires-Dist: grpcio<2.0.0,>=1.78.0
 Provides-Extra: all
 Requires-Dist: deadline-budget<1.0.0,>=0.1.0; extra == 'all'
+Requires-Dist: dishka<2.0.0,>=1.4.0; extra == 'all'
 Requires-Dist: grpcio-health-checking<2.0.0,>=1.78.0; extra == 'all'
 Requires-Dist: opentelemetry-api<2.0.0,>=1.30.0; extra == 'all'
 Requires-Dist: prometheus-client<1.0.0,>=0.20.0; extra == 'all'
+Requires-Dist: pydantic<3.0,>=2.0.0; extra == 'all'
 Provides-Extra: deadline
 Requires-Dist: deadline-budget<1.0.0,>=0.1.0; extra == 'deadline'
+Provides-Extra: dishka
+Requires-Dist: dishka<2.0.0,>=1.4.0; extra == 'dishka'
 Provides-Extra: health
 Requires-Dist: grpcio-health-checking<2.0.0,>=1.78.0; extra == 'health'
 Provides-Extra: metrics
@@ -235,6 +239,8 @@ Requires-Dist: prometheus-client<1.0.0,>=0.20.0; extra == 'metrics'
 Provides-Extra: observability
 Requires-Dist: opentelemetry-api<2.0.0,>=1.30.0; extra == 'observability'
 Requires-Dist: prometheus-client<1.0.0,>=0.20.0; extra == 'observability'
+Provides-Extra: settings
+Requires-Dist: pydantic<3.0,>=2.0.0; extra == 'settings'
 Provides-Extra: tracing
 Requires-Dist: opentelemetry-api<2.0.0,>=1.30.0; extra == 'tracing'
 Description-Content-Type: text/markdown
@@ -307,6 +313,8 @@ pip install "grpc-client-kit[health]"             # + grpc.health.v1 monitoring
 pip install "grpc-client-kit[metrics,tracing]"    # + Prometheus + OpenTelemetry
 pip install "grpc-client-kit[observability]"      # + metrics and tracing together
 pip install "grpc-client-kit[deadline]"           # + request budget propagation
+pip install "grpc-client-kit[settings]"           # + pydantic settings models
+pip install "grpc-client-kit[dishka]"             # + Dishka providers
 pip install "grpc-client-kit[all]"                # everything
 ```
 
@@ -362,7 +370,11 @@ Any object carrying the fields of `GrpcClientSettingsProtocol` works —
 a pydantic model, a dataclass, a plain class. Everything optional
 (`credentials`, `options`, `compression`, `metrics_registry`,
 `sensitive_headers`) is read through `getattr`, so a minimal settings object
-stays valid. See the
+stays valid. Or take the shipped one: `grpc_client_kit.settings.BaseGrpcClientSettings`
+(the `[settings]` extra) is that shape written down once — plain pydantic
+models with the kit's own defaults and bounds, one per upstream, nested under
+your service's `BaseSettings` for loading from the environment, and
+`to_config()` on every section for a hand-built chain. See the
 [configuration guide](https://bedrock-python.github.io/grpc-client-kit/guide/configuration/)
 for the full field list.
 
@@ -511,12 +523,15 @@ names the extra to install.
 | `channel.ChannelPool` | Channels pooled by full identity, idle eviction, health flags | core |
 | `client.GrpcClient` | Stub factory: target selection + channel acquisition | core |
 | `factory.GrpcClientFactory` | Settings → pool, balancer, health checker, per-target chains | core |
+| `settings.BaseGrpcClientSettings` | The settings shape as pydantic models mirroring the dataclasses, `to_config()` on each | `settings` |
 | `balancers.*` | Round-robin / random / weighted selection with health filtering | core |
 | `interceptors.*` | Context, logging, timeout, wait-for-ready, retry, circuit breaker + chain builder | core |
 | `deadline` + `interceptors.deadline` | The request budget in a contextvar, and the layer that trims every call to it | `deadline` |
 | `interceptors.tracing` | OpenTelemetry CLIENT spans and `traceparent` injection | `tracing` |
 | `interceptors.metrics` | Counters, latency histograms and an in-flight gauge | core¹ |
+| `metrics.GrpcClientMetrics` | The Prometheus collector for them, shaped to join `grpc-server-kit`'s series | `metrics` |
 | `health.HealthChecker` | Background `grpc.health.v1` probing with per-target backoff | `health` |
+| `dishka.*` | Dishka providers owning the factory's lifecycle, one component per upstream | `dishka` |
 | `protocols` / `validation` / `utils` | Settings seams, target validation, channel and metadata helpers | core |
 
 ¹ The metrics interceptor records through `GrpcClientMetricsProtocol` and works
@@ -528,10 +543,12 @@ with any backend you pass. The `[metrics]` extra only supplies the usual one.
 | :--- | :--- | :--- |
 | `health` | `grpcio-health-checking` | `HealthChecker`, health-aware balancing and pooling |
 | `tracing` | `opentelemetry-api` | `AsyncClientTracingInterceptor` (a pass-through without it) |
-| `metrics` | `prometheus-client` | the default metrics backend; a custom registry needs no extra |
+| `metrics` | `prometheus-client` | `GrpcClientMetrics`, the Prometheus collector; a custom registry needs no extra |
 | `deadline` | `deadline-budget` | `AsyncDeadlineBudgetInterceptor` (the layer is skipped without it) |
+| `settings` | `pydantic` | `BaseGrpcClientSettings` and the section models |
+| `dishka` | `dishka` | `grpc_client_providers` and the three providers behind it |
 | `observability` | `metrics` + `tracing` | both of the above |
-| `all` | `deadline` + `health` + `metrics` + `tracing` | everything |
+| `all` | `deadline` + `dishka` + `health` + `metrics` + `settings` + `tracing` | everything |
 
 `deadline` is deliberately not part of `observability`: propagating a budget is
 resilience, not telemetry, and an observability extra should not pull in a
@@ -565,7 +582,8 @@ Full documentation at [bedrock-python.github.io/grpc-client-kit](https://bedrock
 | [Load balancing](https://bedrock-python.github.io/grpc-client-kit/guide/load-balancing/) | round-robin, random and weighted selection with health filtering |
 | [Health](https://bedrock-python.github.io/grpc-client-kit/guide/health/) | `grpc.health.v1` probing, per-target backoff and cold starts |
 | [Observability](https://bedrock-python.github.io/grpc-client-kit/guide/observability/) | log records, CLIENT spans and the metrics an RPC emits |
-| [Advanced](https://bedrock-python.github.io/grpc-client-kit/guide/advanced/) | interceptors that re-issue calls, target validation, ownership and DI wiring |
+| [Dependency injection](https://bedrock-python.github.io/grpc-client-kit/guide/dependency-injection/) | the Dishka providers, what they own, and one component per upstream |
+| [Advanced](https://bedrock-python.github.io/grpc-client-kit/guide/advanced/) | interceptors that re-issue calls, target validation and ownership |
 | [API reference](https://bedrock-python.github.io/grpc-client-kit/reference/) | generated from the source |
 | [For AI agents](https://bedrock-python.github.io/grpc-client-kit/agents/) | the whole API surface, the rules that break code when broken and a map of the rest, on one page to hand to a coding assistant |
 

{grpc_client_kit-0.1.2 → grpc_client_kit-0.3.0}/README.md

@@ -66,6 +66,8 @@ pip install "grpc-client-kit[health]"             # + grpc.health.v1 monitoring
 pip install "grpc-client-kit[metrics,tracing]"    # + Prometheus + OpenTelemetry
 pip install "grpc-client-kit[observability]"      # + metrics and tracing together
 pip install "grpc-client-kit[deadline]"           # + request budget propagation
+pip install "grpc-client-kit[settings]"           # + pydantic settings models
+pip install "grpc-client-kit[dishka]"             # + Dishka providers
 pip install "grpc-client-kit[all]"                # everything
 ```
 
@@ -121,7 +123,11 @@ Any object carrying the fields of `GrpcClientSettingsProtocol` works —
 a pydantic model, a dataclass, a plain class. Everything optional
 (`credentials`, `options`, `compression`, `metrics_registry`,
 `sensitive_headers`) is read through `getattr`, so a minimal settings object
-stays valid. See the
+stays valid. Or take the shipped one: `grpc_client_kit.settings.BaseGrpcClientSettings`
+(the `[settings]` extra) is that shape written down once — plain pydantic
+models with the kit's own defaults and bounds, one per upstream, nested under
+your service's `BaseSettings` for loading from the environment, and
+`to_config()` on every section for a hand-built chain. See the
 [configuration guide](https://bedrock-python.github.io/grpc-client-kit/guide/configuration/)
 for the full field list.
 
@@ -270,12 +276,15 @@ names the extra to install.
 | `channel.ChannelPool` | Channels pooled by full identity, idle eviction, health flags | core |
 | `client.GrpcClient` | Stub factory: target selection + channel acquisition | core |
 | `factory.GrpcClientFactory` | Settings → pool, balancer, health checker, per-target chains | core |
+| `settings.BaseGrpcClientSettings` | The settings shape as pydantic models mirroring the dataclasses, `to_config()` on each | `settings` |
 | `balancers.*` | Round-robin / random / weighted selection with health filtering | core |
 | `interceptors.*` | Context, logging, timeout, wait-for-ready, retry, circuit breaker + chain builder | core |
 | `deadline` + `interceptors.deadline` | The request budget in a contextvar, and the layer that trims every call to it | `deadline` |
 | `interceptors.tracing` | OpenTelemetry CLIENT spans and `traceparent` injection | `tracing` |
 | `interceptors.metrics` | Counters, latency histograms and an in-flight gauge | core¹ |
+| `metrics.GrpcClientMetrics` | The Prometheus collector for them, shaped to join `grpc-server-kit`'s series | `metrics` |
 | `health.HealthChecker` | Background `grpc.health.v1` probing with per-target backoff | `health` |
+| `dishka.*` | Dishka providers owning the factory's lifecycle, one component per upstream | `dishka` |
 | `protocols` / `validation` / `utils` | Settings seams, target validation, channel and metadata helpers | core |
 
 ¹ The metrics interceptor records through `GrpcClientMetricsProtocol` and works
@@ -287,10 +296,12 @@ with any backend you pass. The `[metrics]` extra only supplies the usual one.
 | :--- | :--- | :--- |
 | `health` | `grpcio-health-checking` | `HealthChecker`, health-aware balancing and pooling |
 | `tracing` | `opentelemetry-api` | `AsyncClientTracingInterceptor` (a pass-through without it) |
-| `metrics` | `prometheus-client` | the default metrics backend; a custom registry needs no extra |
+| `metrics` | `prometheus-client` | `GrpcClientMetrics`, the Prometheus collector; a custom registry needs no extra |
 | `deadline` | `deadline-budget` | `AsyncDeadlineBudgetInterceptor` (the layer is skipped without it) |
+| `settings` | `pydantic` | `BaseGrpcClientSettings` and the section models |
+| `dishka` | `dishka` | `grpc_client_providers` and the three providers behind it |
 | `observability` | `metrics` + `tracing` | both of the above |
-| `all` | `deadline` + `health` + `metrics` + `tracing` | everything |
+| `all` | `deadline` + `dishka` + `health` + `metrics` + `settings` + `tracing` | everything |
 
 `deadline` is deliberately not part of `observability`: propagating a budget is
 resilience, not telemetry, and an observability extra should not pull in a
@@ -324,7 +335,8 @@ Full documentation at [bedrock-python.github.io/grpc-client-kit](https://bedrock
 | [Load balancing](https://bedrock-python.github.io/grpc-client-kit/guide/load-balancing/) | round-robin, random and weighted selection with health filtering |
 | [Health](https://bedrock-python.github.io/grpc-client-kit/guide/health/) | `grpc.health.v1` probing, per-target backoff and cold starts |
 | [Observability](https://bedrock-python.github.io/grpc-client-kit/guide/observability/) | log records, CLIENT spans and the metrics an RPC emits |
-| [Advanced](https://bedrock-python.github.io/grpc-client-kit/guide/advanced/) | interceptors that re-issue calls, target validation, ownership and DI wiring |
+| [Dependency injection](https://bedrock-python.github.io/grpc-client-kit/guide/dependency-injection/) | the Dishka providers, what they own, and one component per upstream |
+| [Advanced](https://bedrock-python.github.io/grpc-client-kit/guide/advanced/) | interceptors that re-issue calls, target validation and ownership |
 | [API reference](https://bedrock-python.github.io/grpc-client-kit/reference/) | generated from the source |
 | [For AI agents](https://bedrock-python.github.io/grpc-client-kit/agents/) | the whole API surface, the rules that break code when broken and a map of the rest, on one page to hand to a coding assistant |
 

grpc_client_kit-0.3.0/grpc_client_kit/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"  # x-release-please-version

grpc_client_kit-0.3.0/grpc_client_kit/dishka.py

@@ -0,0 +1,183 @@
+"""Dishka providers owning the client lifecycle (``[dishka]`` extra).
+
+What an application otherwise writes by hand — build the factory from the settings, start the health
+checker with the container, close the pool with it — lives here as three providers, one per thing a
+container hands out, and a bundle registering all three::
+
+    from dishka import make_async_container
+
+    from grpc_client_kit import GrpcClientFactory
+    from grpc_client_kit.dishka import grpc_client_providers
+
+    container = make_async_container(*grpc_client_providers(settings.users_grpc))
+    factory = await container.get(GrpcClientFactory)
+    users = factory.create_client(UserStub)
+    ...
+    await container.close()  # stops the checker, closes the pool
+
+- `GrpcClientSettingsProvider` holds the settings object and provides it as
+  `protocols.GrpcClientSettingsProtocol`, so `settings.BaseGrpcClientSettings` or anything structural
+  works.
+- `PrometheusGrpcClientMetricsProvider` provides ``GrpcClientMetricsProtocol | None``: the cached
+  `metrics.GrpcClientMetrics` when ``settings.metrics_enabled``, ``None`` otherwise — ``None`` being
+  the kit's own spelling of "no metrics", which the factory leaves the layer out for.
+- `AsyncGrpcClientProvider` provides `factory.GrpcClientFactory` in APP scope from an async generator,
+  entered when first resolved and left when the container closes.
+
+Several upstreams in one container are Dishka components: every provider takes ``component=``, so
+one bundle per upstream, each in its own component, is one factory per upstream::
+
+    container = make_async_container(
+        *grpc_client_providers(settings.users_grpc, component="users"),
+        *grpc_client_providers(settings.orders_grpc, component="orders"),
+    )
+    users = await container.get(GrpcClientFactory, component="users")
+
+Dishka resolves a component's dependencies inside that component, which is why each one carries its
+own three providers; the collector they hand out is the same instance, cached per prefix, and its
+series are told apart by ``service``. A single upstream uses the default component and needs none of
+this.
+
+This module needs the ``dishka`` extra (``grpc-client-kit[dishka]``); importing it without raises an
+``ImportError`` naming the extra.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import AsyncIterator
+
+try:
+    from dishka import Provider, Scope, provide
+except ImportError as exc:
+    raise ImportError("Install grpc-client-kit[dishka] (dishka) to use the Dishka providers") from exc
+
+from .factory import GrpcClientFactory
+from .interceptors.metrics import HAS_METRICS
+from .protocols import GrpcClientMetricsProtocol, GrpcClientSettingsProtocol
+
+logger = logging.getLogger(__name__)
+
+
+class GrpcClientSettingsProvider(Provider):
+    """Provide one upstream's settings object as ``GrpcClientSettingsProtocol``.
+
+    Construct it with anything structurally satisfying the protocol — `settings.BaseGrpcClientSettings`,
+    a dataclass, a plain class. The other providers request the settings through the protocol, which
+    is what lets a second upstream be a second component rather than a second container.
+    """
+
+    scope = Scope.APP
+
+    def __init__(self, settings: GrpcClientSettingsProtocol, *, component: str | None = None) -> None:
+        super().__init__(component=component)
+        self._settings = settings
+
+    @provide
+    def settings(self) -> GrpcClientSettingsProtocol:
+        """Provide the settings object as it was given."""
+        return self._settings
+
+
+class PrometheusGrpcClientMetricsProvider(Provider):
+    """Provide the registry the factory records into: `metrics.GrpcClientMetrics`, or ``None``.
+
+    ``None`` when ``settings.metrics_enabled`` is off, and ``None`` with a warning when it is on but
+    the ``[metrics]`` extra is absent — the degradation the chain builder applies, so the provider can
+    always be registered. The collector comes from `metrics.get_grpc_client_metrics`, one instance per
+    prefix on the default registry, so a container rebuilt per test never asks Prometheus to register
+    the same series twice.
+    """
+
+    scope = Scope.APP
+
+    def __init__(self, *, prefix: str | None = None, component: str | None = None) -> None:
+        super().__init__(component=component)
+        self._prefix = prefix
+
+    @provide
+    def metrics(self, settings: GrpcClientSettingsProtocol) -> GrpcClientMetricsProtocol | None:
+        """Provide the collector when metrics are enabled and the extra is installed, ``None`` otherwise."""
+        if not settings.metrics_enabled:
+            return None
+        if not HAS_METRICS:
+            logger.warning("Metrics requested but grpc-client-kit[metrics] is not installed; metrics are disabled")
+            return None
+        from .metrics import get_grpc_client_metrics  # noqa: PLC0415 - lazy: needs the [metrics] extra
+
+        return get_grpc_client_metrics(self._prefix)
+
+
+class AsyncGrpcClientProvider(Provider):
+    """Provide `factory.GrpcClientFactory` in APP scope, entered on first use and closed with the container.
+
+    The factory builds and owns the pool and the health checker: resolving it starts the checker and
+    waits for its first pass (``ready_timeout``); closing the container stops the checker and closes
+    the pool, giving in-flight RPCs ``shutdown_grace`` — exactly what ``async with factory`` does.
+    Clients come from the factory as usual, ``factory.create_client(UserStub)``, and are cheap enough
+    to be request-scoped.
+    """
+
+    scope = Scope.APP
+
+    def __init__(
+        self,
+        *,
+        shutdown_grace: float | None = 5.0,
+        ready_timeout: float | None = 10.0,
+        component: str | None = None,
+    ) -> None:
+        super().__init__(component=component)
+        self._shutdown_grace = shutdown_grace
+        self._ready_timeout = ready_timeout
+
+    @provide
+    async def factory(
+        self,
+        settings: GrpcClientSettingsProtocol,
+        metrics: GrpcClientMetricsProtocol | None,
+    ) -> AsyncIterator[GrpcClientFactory]:
+        """Build the factory from the settings and the registry, and close it with the container."""
+        async with GrpcClientFactory(
+            settings=settings,
+            shutdown_grace=self._shutdown_grace,
+            ready_timeout=self._ready_timeout,
+            metrics=metrics,
+        ) as factory:
+            yield factory
+
+
+def grpc_client_providers(
+    settings: GrpcClientSettingsProtocol,
+    *,
+    component: str | None = None,
+    metrics_prefix: str | None = None,
+    shutdown_grace: float | None = 5.0,
+    ready_timeout: float | None = 10.0,
+) -> tuple[Provider, ...]:
+    """Return the three providers of one upstream, for one-line registration.
+
+    Args:
+        settings: The upstream's settings object; anything satisfying `protocols.GrpcClientSettingsProtocol`.
+        component: The Dishka component to register the providers in — one per upstream when a
+            container serves several, the default component otherwise.
+        metrics_prefix: Prefix for the Prometheus metric names.
+        shutdown_grace: Seconds in-flight RPCs get to finish when the container closes.
+        ready_timeout: Seconds the factory waits for the first health check pass when resolved.
+
+    Returns:
+        The providers, to unpack into ``make_async_container``.
+    """
+    return (
+        GrpcClientSettingsProvider(settings, component=component),
+        PrometheusGrpcClientMetricsProvider(prefix=metrics_prefix, component=component),
+        AsyncGrpcClientProvider(shutdown_grace=shutdown_grace, ready_timeout=ready_timeout, component=component),
+    )
+
+
+__all__ = [
+    "AsyncGrpcClientProvider",
+    "GrpcClientSettingsProvider",
+    "PrometheusGrpcClientMetricsProvider",
+    "grpc_client_providers",
+]

{grpc_client_kit-0.1.2 → grpc_client_kit-0.3.0}/grpc_client_kit/factory.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+from dataclasses import fields
 from typing import TYPE_CHECKING, Any
 
 import grpc.aio
@@ -8,7 +9,7 @@ import grpc.aio
 from .balancers import LoadBalancer, LoadBalancerConfig, LoadBalancingStrategy, create_balancer
 from .channel import ChannelPool
 from .client import GrpcClient
-from .config import GrpcClientConfig
+from .config import ConnectivityConfig, GrpcClientConfig
 from .interceptors import (
     CircuitBreakerConfig,
     DeadlineBudgetConfig,
@@ -35,6 +36,10 @@ logger = logging.getLogger(__name__)
 
 _MISSING_MESSAGE = "Install grpc-client-kit[health] (grpcio-health-checking) to use gRPC health checking"
 
+# What a duck-typed `connectivity` block may carry: the dataclass's own fields, so a knob added there
+# is read from settings without this module having to hear about it.
+_CONNECTIVITY_FIELDS = tuple(field.name for field in fields(ConnectivityConfig))
+
 
 def _validate_settings(settings: object | None) -> None:
     """Refuse a settings object that cannot satisfy the factory, while the mistake is visible.
@@ -93,6 +98,7 @@ class GrpcClientFactory:
         pool: ChannelProviderProtocol | None = None,
         shutdown_grace: float | None = 5.0,
         ready_timeout: float | None = 10.0,
+        metrics: GrpcClientMetricsProtocol | None = None,
     ) -> None:
         """Initialize the factory.
 
@@ -113,6 +119,12 @@ class GrpcClientFactory:
                 that pass every target reads unhealthy, so entering the context without waiting
                 would make the first call of every freshly started pod fail deterministically.
                 ``None`` waits indefinitely; only relevant when health checking is configured.
+            metrics: The registry RPC metrics, retries, breaker state and pool statistics are
+                recorded into: the default for every client this factory creates, and the one
+                the pool it creates reports to. Wins over ``settings.metrics_registry``;
+                `create_client(metrics=...)` wins over it per client. The shipped settings
+                models carry no registry, a registry being a runtime object, so this is where
+                one meets them.
 
         Raises:
             TypeError: If `settings` does not satisfy `GrpcClientSettingsProtocol`. Validated
@@ -130,21 +142,24 @@ class GrpcClientFactory:
         # reuse the same interceptor instances, or every create_client would mint a fresh channel
         # identity and a per-request client pattern would open a connection per request.
         self._chains: dict[tuple[str, str], list[grpc.aio.ClientInterceptor]] = {}
+        # The registry every client and the owned pool default to: the explicit one, else the
+        # settings' own — the shipped settings models carry none, a registry being a runtime object.
+        settings_registry = getattr(settings, "metrics_registry", None) if settings else None
+        self._metrics: GrpcClientMetricsProtocol | None = metrics if metrics is not None else settings_registry
 
         if pool:
             self._pool = pool
         else:
             self._owns_pool = True
-            metrics = getattr(settings, "metrics_registry", None) if settings else None
 
             if settings and settings.pool:
                 self._pool = ChannelPool(
                     max_channels_per_target=settings.pool.max_channels_per_target,
                     idle_timeout=settings.pool.idle_timeout,
-                    metrics=metrics,
+                    metrics=self._metrics,
                 )
             else:
-                self._pool = ChannelPool(metrics=metrics)
+                self._pool = ChannelPool(metrics=self._metrics)
 
         # Build and start HealthChecker if configured and we have targets
         if settings and settings.health_checker and settings.targets:
@@ -247,7 +262,8 @@ class GrpcClientFactory:
             stub_class: The gRPC stub class to instantiate.
             target: Optional target override. If not provided, uses target from settings.
             service_name: Name of the service for observability. Defaults to stub class name.
-            metrics: Optional metrics registry, overriding `settings.metrics_registry`.
+            metrics: Optional metrics registry for this client alone, overriding the factory's
+                ``metrics`` and `settings.metrics_registry`.
             interceptors: Optional list of additional custom interceptors. These instances are
                 shared by every target, unlike the chain the factory builds around them.
 
@@ -306,6 +322,10 @@ class GrpcClientFactory:
                         metrics_registry=metrics_registry,
                         service_name=actual_service_name,
                         sensitive_headers=getattr(self._settings, "sensitive_headers", None),
+                        sensitive_methods=getattr(self._settings, "sensitive_methods", None),
+                        sensitive_patterns=getattr(self._settings, "sensitive_patterns", None),
+                        log_request_payload=getattr(self._settings, "log_request_payload", False),
+                        log_response_payload=getattr(self._settings, "log_response_payload", False),
                         enable_method_label=getattr(self._settings, "enable_method_label", True),
                         success_log_level=getattr(self._settings, "success_log_level", logging.INFO),
                     )
@@ -344,8 +364,9 @@ class GrpcClientFactory:
     def _resolve_metrics_registry(self, metrics: GrpcClientMetricsProtocol | None) -> GrpcClientMetricsProtocol | None:
         """Pick the registry RPC metrics are recorded into.
 
-        An explicit argument wins over `settings.metrics_registry`, which otherwise only fed pool
-        statistics and left `metrics_enabled` clients recording nothing at all.
+        An explicit argument wins over the factory's default — its own ``metrics`` argument, else
+        `settings.metrics_registry`, which otherwise only fed pool statistics and left
+        `metrics_enabled` clients recording nothing at all.
 
         Args:
             metrics: The registry passed to `create_client`, if any.
@@ -353,13 +374,12 @@ class GrpcClientFactory:
         Returns:
             The registry to use, or None if metrics cannot be recorded.
         """
-        settings_registry = getattr(self._settings, "metrics_registry", None) if self._settings else None
-        registry: GrpcClientMetricsProtocol | None = metrics if metrics is not None else settings_registry
+        registry: GrpcClientMetricsProtocol | None = metrics if metrics is not None else self._metrics
 
         if registry is None and self._settings and self._settings.metrics_enabled:
             logger.warning(
                 "metrics_enabled is set but no metrics registry is available. "
-                "Pass 'metrics=' to create_client() or set 'metrics_registry' in settings; "
+                "Pass 'metrics=' to the factory or to create_client(), or set 'metrics_registry' in settings; "
                 "gRPC client metrics are disabled."
             )
 
@@ -371,8 +391,8 @@ class GrpcClientFactory:
         Channel construction settings are optional blocks (see `protocols.GrpcChannelExtrasProtocol`)
         and are read with `getattr`, so a settings model that declares none of them still satisfies
         the factory. ``connectivity`` joins them on the same terms: a settings object that carries a
-        `config.ConnectivityConfig` under that name has its channels tuned by it, and one that does
-        not is left with gRPC's defaults.
+        `config.ConnectivityConfig` — or a block with its fields — under that name has its channels
+        tuned by it, and one that does not is left with gRPC's defaults.
         """
         if self._settings:
             actual_target = target or self._settings.target
@@ -380,7 +400,7 @@ class GrpcClientFactory:
             credentials = getattr(self._settings, "credentials", None)
             options = getattr(self._settings, "options", None)
             compression = getattr(self._settings, "compression", None)
-            connectivity = getattr(self._settings, "connectivity", None)
+            connectivity = self._build_connectivity_config(getattr(self._settings, "connectivity", None))
         else:
             actual_target = target
             insecure = False
@@ -422,11 +442,23 @@ class GrpcClientFactory:
             health_checker=self._health_checker,
         )
 
+    def _build_connectivity_config(self, s: Any | None) -> ConnectivityConfig | None:
+        """Build ConnectivityConfig from an optional settings block (duck-typed).
+
+        A ready `config.ConnectivityConfig` is taken as it is. Any other block is read field by
+        field, and a field it does not carry keeps the dataclass's own default.
+        """
+        if not s:
+            return None
+        if isinstance(s, ConnectivityConfig):
+            return s
+        return ConnectivityConfig(**{name: getattr(s, name) for name in _CONNECTIVITY_FIELDS if hasattr(s, name)})
+
     def _build_timeout_config(self, s: TimeoutSettingsProtocol | None) -> TimeoutConfig | None:
-        """Build TimeoutConfig from settings protocol."""
+        """Build TimeoutConfig from settings protocol; per-method budgets are read when the block has them."""
         if not s:
             return None
-        return TimeoutConfig(default=s.default)
+        return TimeoutConfig(default=s.default, per_method=dict(getattr(s, "per_method", None) or {}))
 
     def _build_retry_config(
         self, s: RetrySettingsProtocol | None, metrics: GrpcClientMetricsProtocol | None = None