kurrentdbclient 1.2.1__tar.gz → 1.2.2__tar.gz

{kurrentdbclient-1.2.1 → kurrentdbclient-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kurrentdbclient
-Version: 1.2.1
+Version: 1.2.2
 Summary: Python gRPC Client for KurrentDB
 License: BSD-3-Clause
 License-File: LICENSE

{kurrentdbclient-1.2.1 → kurrentdbclient-1.2.2}/kurrentdbclient/__init__.py

@@ -26,7 +26,7 @@ from kurrentdbclient.streams import (
     ReadResponse,
 )
 
-__version__ = "1.2.1"
+__version__ = "1.2.2"
 
 __all__ = [
     "DEFAULT_EXCLUDE_FILTER",

{kurrentdbclient-1.2.1 → kurrentdbclient-1.2.2}/kurrentdbclient/instrumentation/opentelemetry/__init__.py

@@ -20,6 +20,7 @@ from kurrentdbclient.instrumentation.opentelemetry.spanners import (
     span_append_to_stream,
     span_catchup_subscription,
     span_get_stream,
+    span_multi_append_to_stream,
     span_persistent_subscription,
     span_read_stream,
 )
@@ -68,6 +69,12 @@ class KurrentDBClientInstrumentor(_BaseInstrumentor):
             spanner_func=span_append_to_stream,
             tracer=tracer,
         )
+        apply_spanner(
+            patched_class=KurrentDBClient,
+            spanned_func=KurrentDBClient.multi_append_to_stream,
+            spanner_func=span_multi_append_to_stream,
+            tracer=tracer,
+        )
         apply_spanner(
             patched_class=KurrentDBClient,
             spanned_func=KurrentDBClient.subscribe_to_stream,
@@ -112,6 +119,7 @@ class KurrentDBClientInstrumentor(_BaseInstrumentor):
 
     def _uninstrument(self, **kwargs: Any) -> None:
         unwrap(KurrentDBClient, "append_to_stream")
+        unwrap(KurrentDBClient, "multi_append_to_stream")
         unwrap(KurrentDBClient, "subscribe_to_stream")
         unwrap(KurrentDBClient, "subscribe_to_all")
         unwrap(KurrentDBClient, "read_subscription_to_stream")
@@ -136,6 +144,12 @@ class AsyncKurrentDBClientInstrumentor(_BaseInstrumentor):
             spanner_func=span_append_to_stream,
             tracer=tracer,
         )
+        apply_spanner(
+            patched_class=AsyncKurrentDBClient,
+            spanned_func=AsyncKurrentDBClient.multi_append_to_stream,
+            spanner_func=span_multi_append_to_stream,
+            tracer=tracer,
+        )
         apply_spanner(
             patched_class=AsyncKurrentDBClient,
             spanned_func=AsyncKurrentDBClient.subscribe_to_stream,
@@ -176,6 +190,7 @@ class AsyncKurrentDBClientInstrumentor(_BaseInstrumentor):
 
     def _uninstrument(self, **kwargs: Any) -> None:
         unwrap(AsyncKurrentDBClient, "append_to_stream")
+        unwrap(AsyncKurrentDBClient, "multi_append_to_stream")
         unwrap(AsyncKurrentDBClient, "subscribe_to_stream")
         unwrap(AsyncKurrentDBClient, "subscribe_to_all")
         unwrap(AsyncKurrentDBClient, "read_subscription_to_stream")

{kurrentdbclient-1.2.1 → kurrentdbclient-1.2.2}/kurrentdbclient/instrumentation/opentelemetry/spanners.py

@@ -32,6 +32,7 @@ from kurrentdbclient import (
     AsyncReadResponse,
     KurrentDBClient,
     NewEvent,
+    NewEvents,
     ReadResponse,
     RecordedEvent,
     StreamState,
@@ -70,14 +71,17 @@ if TYPE_CHECKING:
 
 
 STREAMS_APPEND = "streams.append"
+STREAMS_MULTI_APPEND = "streams.multi-append"
 STREAMS_SUBSCRIBE = "streams.subscribe"
 SPAN_NAMES_BY_CLIENT_METHOD = {
     KurrentDBClient.append_to_stream.__qualname__: STREAMS_APPEND,
+    KurrentDBClient.multi_append_to_stream.__qualname__: STREAMS_MULTI_APPEND,
     KurrentDBClient.subscribe_to_all.__qualname__: STREAMS_SUBSCRIBE,
     KurrentDBClient.subscribe_to_stream.__qualname__: STREAMS_SUBSCRIBE,
     KurrentDBClient.read_subscription_to_all.__qualname__: STREAMS_SUBSCRIBE,
     KurrentDBClient.read_subscription_to_stream.__qualname__: STREAMS_SUBSCRIBE,
     AsyncKurrentDBClient.append_to_stream.__qualname__: STREAMS_APPEND,
+    AsyncKurrentDBClient.multi_append_to_stream.__qualname__: STREAMS_MULTI_APPEND,
     AsyncKurrentDBClient.subscribe_to_all.__qualname__: STREAMS_SUBSCRIBE,
     AsyncKurrentDBClient.subscribe_to_stream.__qualname__: STREAMS_SUBSCRIBE,
     AsyncKurrentDBClient.read_subscription_to_all.__qualname__: STREAMS_SUBSCRIBE,
@@ -85,11 +89,13 @@ SPAN_NAMES_BY_CLIENT_METHOD = {
 }
 SPAN_KINDS_BY_CLIENT_METHOD = {
     KurrentDBClient.append_to_stream.__qualname__: SpanKind.PRODUCER,
+    KurrentDBClient.multi_append_to_stream.__qualname__: SpanKind.PRODUCER,
     KurrentDBClient.subscribe_to_all.__qualname__: SpanKind.CONSUMER,
     KurrentDBClient.subscribe_to_stream.__qualname__: SpanKind.CONSUMER,
     KurrentDBClient.read_subscription_to_all.__qualname__: SpanKind.CONSUMER,
     KurrentDBClient.read_subscription_to_stream.__qualname__: SpanKind.CONSUMER,
     AsyncKurrentDBClient.append_to_stream.__qualname__: SpanKind.PRODUCER,
+    AsyncKurrentDBClient.multi_append_to_stream.__qualname__: SpanKind.PRODUCER,
     AsyncKurrentDBClient.subscribe_to_all.__qualname__: SpanKind.CONSUMER,
     AsyncKurrentDBClient.subscribe_to_stream.__qualname__: SpanKind.CONSUMER,
     AsyncKurrentDBClient.read_subscription_to_all.__qualname__: SpanKind.CONSUMER,
@@ -346,6 +352,30 @@ class AsyncAppendToStreamMethod(Protocol):
         pass  # pragma: no cover
 
 
+class MultiAppendToStreamMethod(Protocol):
+    def __call__(
+        self,
+        /,
+        events: NewEvents | Iterable[NewEvents],
+        *,
+        timeout: float | None = None,
+        credentials: grpc.CallCredentials | None = None,
+    ) -> int:
+        pass  # pragma: no cover
+
+
+class AsyncMultiAppendToStreamMethod(Protocol):
+    async def __call__(
+        self,
+        /,
+        events: NewEvents | Iterable[NewEvents],
+        *,
+        timeout: float | None = None,
+        credentials: grpc.CallCredentials | None = None,
+    ) -> int:
+        pass  # pragma: no cover
+
+
 @overload
 def span_append_to_stream(
     tracer: Tracer,
@@ -401,7 +431,7 @@ def span_append_to_stream(
                 db_operation_name=span_name,
                 stream_name=stream_name,
             )
-            events = _set_context_in_events(span.get_span_context(), events)
+            events = _set_context_in_new_event_objects(span.get_span_context(), events)
             yield spanned_func(
                 stream_name,
                 current_version=current_version,
@@ -416,6 +446,67 @@ def span_append_to_stream(
             _set_span_ok(span)
 
 
+@overload
+def span_multi_append_to_stream(
+    tracer: Tracer,
+    instance: BaseKurrentDBClient,
+    spanned_func: AsyncMultiAppendToStreamMethod,
+    /,
+    events: NewEvents | Iterable[NewEvents],
+    *,
+    timeout: float | None = None,
+    credentials: grpc.CallCredentials | None = None,
+) -> AsyncSpannerResponse[int]:
+    pass  # pragma: no cover
+
+
+@overload
+def span_multi_append_to_stream(
+    tracer: Tracer,
+    instance: BaseKurrentDBClient,
+    spanned_func: MultiAppendToStreamMethod,
+    /,
+    events: NewEvents | Iterable[NewEvents],
+    *,
+    timeout: float | None = None,
+    credentials: grpc.CallCredentials | None = None,
+) -> SpannerResponse[int]:
+    pass  # pragma: no cover
+
+
+def span_multi_append_to_stream(
+    tracer: Tracer,
+    instance: BaseKurrentDBClient,
+    spanned_func: MultiAppendToStreamMethod | AsyncMultiAppendToStreamMethod,
+    /,
+    events: NewEvents | Iterable[NewEvents],
+    *,
+    timeout: float | None = None,
+    credentials: grpc.CallCredentials | None = None,
+) -> OverloadedSpannerResponse[int, int]:  # pragma: <25.1 no cover
+
+    span_name, span_kind = _get_span_name_and_kind(spanned_func)
+
+    with _start_span(tracer, span_name, span_kind) as span:
+        try:
+            _enrich_span(
+                span=span,
+                client=instance,
+                db_operation_name=span_name,
+            )
+            events = _set_context_in_new_events_objects(span.get_span_context(), events)
+            yield spanned_func(
+                events=events,
+                timeout=timeout,
+                credentials=credentials,
+            )
+        except Exception as e:
+            _set_span_error(span, e)
+            raise
+        else:
+            _set_span_ok(span)
+
+
 class CatchupSubscriptionMethod(Protocol):
     def __call__(
         self,
@@ -1035,7 +1126,7 @@ METADATA_TRACE_ID = "$traceId"
 METADATA_SPAN_ID = "$spanId"
 
 
-def _set_context_in_events(
+def _set_context_in_new_event_objects(
     context: SpanContext, events: NewEvent | Iterable[NewEvent]
 ) -> Sequence[NewEvent]:
     # Kind of propagate OpenTelemetry context in "standard KurrentDB" style.
@@ -1063,6 +1154,25 @@ def _set_context_in_events(
     return reconstructed_events
 
 
+def _set_context_in_new_events_objects(
+    context: SpanContext, events: NewEvents | Iterable[NewEvents]
+) -> Sequence[NewEvents]:  # pragma: <25.1 no cover
+    # Kind of propagate OpenTelemetry context in "standard KurrentDB" style.
+    if isinstance(events, NewEvents):
+        events = [events]
+    return [
+        NewEvents(
+            new_events_obj.stream_name,
+            _set_context_in_new_event_objects(
+                context,
+                new_events_obj.events,
+            ),
+            current_version=new_events_obj.current_version,
+        )
+        for new_events_obj in events
+    ]
+
+
 def _extract_context_from_event(
     recorded_event: NewEvent | RecordedEvent,
 ) -> Context | None:

{kurrentdbclient-1.2.1 → kurrentdbclient-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "kurrentdbclient"
-version = "1.2.1"
+version = "1.2.2"
 description = "Python gRPC Client for KurrentDB"
 license = { text = "BSD-3-Clause" }
 readme = "README.md"