opentelemetry-instrumentation-confluent-kafka 0.45b0__tar.gz → 0.47b0__tar.gz

{opentelemetry_instrumentation_confluent_kafka-0.45b0 → opentelemetry_instrumentation_confluent_kafka-0.47b0}/.gitignore

@@ -58,3 +58,6 @@ _build/
 # mypy
 .mypy_cache/
 target
+
+# Benchmark result files
+*-benchmark.json

{opentelemetry_instrumentation_confluent_kafka-0.45b0 → opentelemetry_instrumentation_confluent_kafka-0.47b0}/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright The OpenTelemetry Authors
+   Copyright [yyyy] [name of copyright owner]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

{opentelemetry_instrumentation_confluent_kafka-0.45b0 → opentelemetry_instrumentation_confluent_kafka-0.47b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: opentelemetry-instrumentation-confluent-kafka
-Version: 0.45b0
+Version: 0.47b0
 Summary: OpenTelemetry Confluent Kafka instrumentation
 Project-URL: Homepage, https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation/opentelemetry-instrumentation-confluent-kafka
 Author-email: OpenTelemetry Authors <cncf-opentelemetry-contributors@lists.cncf.io>
@@ -12,12 +12,16 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
 Requires-Dist: opentelemetry-api~=1.12
-Requires-Dist: opentelemetry-instrumentation==0.45b0
+Requires-Dist: opentelemetry-instrumentation==0.47b0
 Requires-Dist: wrapt<2.0.0,>=1.0.0
 Provides-Extra: instruments
-Requires-Dist: confluent-kafka<=2.3.0,>=1.8.2; extra == 'instruments'
+Requires-Dist: confluent-kafka<=2.4.0,>=1.8.2; extra == 'instruments'
 Description-Content-Type: text/x-rst
 
 OpenTelemetry confluent-kafka Instrumentation

{opentelemetry_instrumentation_confluent_kafka-0.45b0 → opentelemetry_instrumentation_confluent_kafka-0.47b0}/pyproject.toml

@@ -19,16 +19,20 @@ classifiers = [
   "Programming Language :: Python",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
-  "opentelemetry-instrumentation == 0.45b0",
+  "opentelemetry-instrumentation == 0.47b0",
   "opentelemetry-api ~= 1.12",
   "wrapt >= 1.0.0, < 2.0.0",
 ]
 
 [project.optional-dependencies]
 instruments = [
-  "confluent-kafka >= 1.8.2, <= 2.3.0",
+  "confluent-kafka >= 1.8.2, <= 2.4.0",
 ]
 
 [project.entry-points.opentelemetry_instrumentor]

{opentelemetry_instrumentation_confluent_kafka-0.45b0 → opentelemetry_instrumentation_confluent_kafka-0.47b0}/src/opentelemetry/instrumentation/confluent_kafka/__init__.py

@@ -144,6 +144,10 @@ class AutoInstrumentedConsumer(Consumer):
     ):  # pylint: disable=useless-super-delegation
         return super().consume(*args, **kwargs)
 
+    # This method is deliberately implemented in order to allow wrapt to wrap this function
+    def close(self):  # pylint: disable=useless-super-delegation
+        return super().close()
+
 
 class ProxiedProducer(Producer):
     def __init__(self, producer: Producer, tracer: Tracer):
@@ -151,10 +155,13 @@ class ProxiedProducer(Producer):
         self._tracer = tracer
 
     def flush(self, timeout=-1):
-        self._producer.flush(timeout)
+        return self._producer.flush(timeout)
 
     def poll(self, timeout=-1):
-        self._producer.poll(timeout)
+        return self._producer.poll(timeout)
+
+    def purge(self, in_queue=True, in_flight=True, blocking=True):
+        self._producer.purge(in_queue, in_flight, blocking)
 
     def produce(
         self, topic, value=None, *args, **kwargs
@@ -178,6 +185,11 @@ class ProxiedConsumer(Consumer):
         self._current_consume_span = None
         self._current_context_token = None
 
+    def close(self):
+        return ConfluentKafkaInstrumentor.wrap_close(
+            self._consumer.close, self
+        )
+
     def committed(self, partitions, timeout=-1):
         return self._consumer.committed(partitions, timeout)
 
@@ -300,6 +312,9 @@ class ConfluentKafkaInstrumentor(BaseInstrumentor):
                 func, instance, self._tracer, args, kwargs
             )
 
+        def _inner_wrap_close(func, instance):
+            return ConfluentKafkaInstrumentor.wrap_close(func, instance)
+
         wrapt.wrap_function_wrapper(
             AutoInstrumentedProducer,
             "produce",
@@ -318,6 +333,12 @@ class ConfluentKafkaInstrumentor(BaseInstrumentor):
             _inner_wrap_consume,
         )
 
+        wrapt.wrap_function_wrapper(
+            AutoInstrumentedConsumer,
+            "close",
+            _inner_wrap_close,
+        )
+
     def _uninstrument(self, **kwargs):
         confluent_kafka.Producer = self._original_kafka_producer
         confluent_kafka.Consumer = self._original_kafka_consumer
@@ -400,3 +421,9 @@ class ConfluentKafkaInstrumentor(BaseInstrumentor):
         )
 
         return records
+
+    @staticmethod
+    def wrap_close(func, instance):
+        if instance._current_consume_span:
+            _end_current_consume_span(instance)
+        func()

{opentelemetry_instrumentation_confluent_kafka-0.45b0 → opentelemetry_instrumentation_confluent_kafka-0.47b0}/src/opentelemetry/instrumentation/confluent_kafka/package.py

@@ -13,4 +13,4 @@
 # limitations under the License.
 
 
-_instruments = ("confluent-kafka >= 1.8.2, <= 2.3.0",)
+_instruments = ("confluent-kafka >= 1.8.2, <= 2.4.0",)

{opentelemetry_instrumentation_confluent_kafka-0.45b0 → opentelemetry_instrumentation_confluent_kafka-0.47b0}/src/opentelemetry/instrumentation/confluent_kafka/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "0.45b0"
+__version__ = "0.47b0"

{opentelemetry_instrumentation_confluent_kafka-0.45b0 → opentelemetry_instrumentation_confluent_kafka-0.47b0}/tests/test_instrumentation.py

@@ -31,7 +31,7 @@ from opentelemetry.semconv.trace import (
 )
 from opentelemetry.test.test_base import TestBase
 
-from .utils import MockConsumer, MockedMessage
+from .utils import MockConsumer, MockedMessage, MockedProducer
 
 
 class TestConfluentKafka(TestBase):
@@ -237,7 +237,44 @@ class TestConfluentKafka(TestBase):
         span_list = self.memory_exporter.get_finished_spans()
         self._compare_spans(span_list, expected_spans)
 
+    def test_close(self) -> None:
+        instrumentation = ConfluentKafkaInstrumentor()
+        mocked_messages = [
+            MockedMessage("topic-a", 0, 0, []),
+        ]
+        expected_spans = [
+            {"name": "recv", "attributes": {}},
+            {
+                "name": "topic-a process",
+                "attributes": {
+                    SpanAttributes.MESSAGING_OPERATION: "process",
+                    SpanAttributes.MESSAGING_KAFKA_PARTITION: 0,
+                    SpanAttributes.MESSAGING_SYSTEM: "kafka",
+                    SpanAttributes.MESSAGING_DESTINATION: "topic-a",
+                    SpanAttributes.MESSAGING_DESTINATION_KIND: MessagingDestinationKindValues.QUEUE.value,
+                    SpanAttributes.MESSAGING_MESSAGE_ID: "topic-a.0.0",
+                },
+            },
+        ]
+
+        consumer = MockConsumer(
+            mocked_messages,
+            {
+                "bootstrap.servers": "localhost:29092",
+                "group.id": "mygroup",
+                "auto.offset.reset": "earliest",
+            },
+        )
+        self.memory_exporter.clear()
+        consumer = instrumentation.instrument_consumer(consumer)
+        consumer.poll()
+        consumer.close()
+
+        span_list = self.memory_exporter.get_finished_spans()
+        self._compare_spans(span_list, expected_spans)
+
     def _compare_spans(self, spans, expected_spans):
+        self.assertEqual(len(spans), len(expected_spans))
         for span, expected_span in zip(spans, expected_spans):
             self.assertEqual(expected_span["name"], span.name)
             for attribute_key, expected_attribute_value in expected_span[
@@ -246,3 +283,35 @@ class TestConfluentKafka(TestBase):
                 self.assertEqual(
                     expected_attribute_value, span.attributes[attribute_key]
                 )
+
+    def test_producer_poll(self) -> None:
+        instrumentation = ConfluentKafkaInstrumentor()
+        message_queue = []
+
+        producer = MockedProducer(
+            message_queue,
+            {
+                "bootstrap.servers": "localhost:29092",
+            },
+        )
+
+        producer = instrumentation.instrument_producer(producer)
+        producer.produce(topic="topic-1", key="key-1", value="value-1")
+        msg = producer.poll()
+        self.assertIsNotNone(msg)
+
+    def test_producer_flush(self) -> None:
+        instrumentation = ConfluentKafkaInstrumentor()
+        message_queue = []
+
+        producer = MockedProducer(
+            message_queue,
+            {
+                "bootstrap.servers": "localhost:29092",
+            },
+        )
+
+        producer = instrumentation.instrument_producer(producer)
+        producer.produce(topic="topic-1", key="key-1", value="value-1")
+        msg = producer.flush()
+        self.assertIsNotNone(msg)

opentelemetry_instrumentation_confluent_kafka-0.47b0/tests/utils.py

@@ -0,0 +1,83 @@
+from typing import Optional
+
+from confluent_kafka import Consumer, Producer
+
+
+class MockConsumer(Consumer):
+    def __init__(self, queue, config):
+        self._queue = queue
+        super().__init__(config)
+
+    def consume(
+        self, num_messages=1, *args, **kwargs
+    ):  # pylint: disable=keyword-arg-before-vararg
+        messages = self._queue[:num_messages]
+        self._queue = self._queue[num_messages:]
+        return messages
+
+    def poll(self, timeout=None):
+        if len(self._queue) > 0:
+            return self._queue.pop(0)
+        return None
+
+
+class MockedMessage:
+    def __init__(
+        self,
+        topic: str,
+        partition: int,
+        offset: int,
+        headers,
+        key: Optional[str] = None,
+        value: Optional[str] = None,
+    ):
+        self._topic = topic
+        self._partition = partition
+        self._offset = offset
+        self._headers = headers
+        self._key = key
+        self._value = value
+
+    def topic(self):
+        return self._topic
+
+    def partition(self):
+        return self._partition
+
+    def offset(self):
+        return self._offset
+
+    def headers(self):
+        return self._headers
+
+    def key(self):
+        return self._key
+
+    def value(self):
+        return self._value
+
+
+class MockedProducer(Producer):
+    def __init__(self, queue, config):
+        self._queue = queue
+        super().__init__(config)
+
+    def produce(
+        self, *args, **kwargs
+    ):  # pylint: disable=keyword-arg-before-vararg
+        self._queue.append(
+            MockedMessage(
+                topic=kwargs.get("topic"),
+                partition=0,
+                offset=0,
+                headers=[],
+                key=kwargs.get("key"),
+                value=kwargs.get("value"),
+            )
+        )
+
+    def poll(self, *args, **kwargs):
+        return len(self._queue)
+
+    def flush(self, *args, **kwargs):
+        return len(self._queue)

opentelemetry_instrumentation_confluent_kafka-0.45b0/tests/utils.py

@@ -1,39 +0,0 @@
-from confluent_kafka import Consumer
-
-
-class MockConsumer(Consumer):
-    def __init__(self, queue, config):
-        self._queue = queue
-        super().__init__(config)
-
-    def consume(
-        self, num_messages=1, *args, **kwargs
-    ):  # pylint: disable=keyword-arg-before-vararg
-        messages = self._queue[:num_messages]
-        self._queue = self._queue[num_messages:]
-        return messages
-
-    def poll(self, timeout=None):
-        if len(self._queue) > 0:
-            return self._queue.pop(0)
-        return None
-
-
-class MockedMessage:
-    def __init__(self, topic: str, partition: int, offset: int, headers):
-        self._topic = topic
-        self._partition = partition
-        self._offset = offset
-        self._headers = headers
-
-    def topic(self):
-        return self._topic
-
-    def partition(self):
-        return self._partition
-
-    def offset(self):
-        return self._offset
-
-    def headers(self):
-        return self._headers