chore: Hide classes that are not needed for the final user

Signed-off-by: Jayson Reis <[email protected]>

Author: jaysonsantos

instrumentation/opentelemetry-instrumentation-pulsar/src/opentelemetry/instrumentation/pulsar/__init__.py

@@ -69,14 +69,13 @@ def consume(consumer, message):
 
 import pulsar
 import wrapt
-from pulsar import Client, Consumer, Message, Producer
-
-from opentelemetry import propagate, trace
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import propagator, unwrap
 from opentelemetry.semconv.trace import MessagingOperationValues
 from opentelemetry.trace import Span, SpanKind, Tracer
+from pulsar import Client, Consumer, Message, Producer
 
+from opentelemetry import propagate, trace
 from .package import _instruments
 from .utils import (
     _enrich_span,
@@ -90,14 +89,14 @@ def consume(consumer, message):
 PROPERTIES_KEY = "properties"
 
 
-class TracerMixin:
+class _TracerMixin:
     _tracer: Tracer
 
     def _set_tracer(self, tracer):
         self._tracer = tracer
 
 
-class SpanMixin:
+class _SpanMixin:
     _current_span: Optional[Span] = None
 
     def _set_current_span(self, current_span):
@@ -110,7 +109,7 @@ def _end_span(self):
                 self._current_span = None
 
 
-class InstrumentedClient(TracerMixin, Client):
+class _InstrumentedClient(_TracerMixin, Client):
     _subscribe_signature = inspect.signature(Client.subscribe)
 
     def subscribe(self, topic, *args, **kwargs):
@@ -125,7 +124,7 @@ def subscribe(self, topic, *args, **kwargs):
 
             @wraps(message_listener)
             def wrapper(  # pylint: disable=function-redefined
-                consumer, message: InstrumentedMessage, *args, **kwargs
+                    consumer, message: _InstrumentedMessage, *args, **kwargs
             ):
                 ctx = propagator.extract(message.properties())
                 span = self._tracer.start_span(
@@ -148,7 +147,7 @@ def wrapper(  # pylint: disable=function-redefined
         return super().subscribe(*args, **bound_arguments.kwargs)
 
 
-class InstrumentedProducer(TracerMixin, Producer):
+class _InstrumentedProducer(_TracerMixin, Producer):
     _send_signature = inspect.signature(Producer.send)
 
     def send(self, *args, **kwargs):
@@ -204,20 +203,20 @@ def _create_span(self):
         )
 
 
-class InstrumentedMessage(Message, SpanMixin):
+class _InstrumentedMessage(Message, _SpanMixin):
     pass
 
 
-class InstrumentedConsumer(TracerMixin, Consumer):
-    _last_message: InstrumentedMessage = None
+class _InstrumentedConsumer(_TracerMixin, Consumer):
+    _last_message: _InstrumentedMessage = None
 
     def receive(self, *args, **kwargs):
         if self._last_message:
             self._last_message._end_span()
         with self._tracer.start_as_current_span(
-            "recv", end_on_exit=True, kind=trace.SpanKind.CONSUMER
+                "recv", end_on_exit=True, kind=trace.SpanKind.CONSUMER
         ):
-            message: InstrumentedMessage = super().receive(*args, **kwargs)
+            message: _InstrumentedMessage = super().receive(*args, **kwargs)
             context = propagate.extract(message.properties())
             span = self._tracer.start_span(
                 f"{self.topic()} process", context=context
@@ -229,19 +228,19 @@ def receive(self, *args, **kwargs):
 
             return message
 
-    def acknowledge(self, message: InstrumentedMessage):
+    def acknowledge(self, message: _InstrumentedMessage):
         message._end_span()
         super().acknowledge(message)
 
     acknowledge.__doc__ = Consumer.acknowledge.__doc__
 
-    def negative_acknowledge(self, message: InstrumentedMessage):
+    def negative_acknowledge(self, message: _InstrumentedMessage):
         message._end_span()
         super().negative_acknowledge(message)
 
     negative_acknowledge.__doc__ = Consumer.negative_acknowledge.__doc__
 
-    def acknowledge_cumulative(self, message: InstrumentedMessage):
+    def acknowledge_cumulative(self, message: _InstrumentedMessage):
         message._end_span()
         super().acknowledge_cumulative(message)
 
@@ -268,10 +267,10 @@ def _instrument(self, **kwargs):
         self._original_pulsar_consumer = pulsar.Consumer
         self._original_pulsar_message = pulsar.Message
 
-        pulsar.Client = InstrumentedClient
-        pulsar.Producer = InstrumentedProducer
-        pulsar.Consumer = InstrumentedConsumer
-        pulsar.Message = InstrumentedMessage
+        pulsar.Client = _InstrumentedClient
+        pulsar.Producer = _InstrumentedProducer
+        pulsar.Consumer = _InstrumentedConsumer
+        pulsar.Message = _InstrumentedMessage
 
         tracer_provider = kwargs.get("tracer_provider")
         tracer = trace.get_tracer(
@@ -284,16 +283,19 @@ def init(wrapped, self, args, kwargs):
             wrapped(*args, **kwargs)
             self._set_tracer(tracer)
 
-        wrapt.wrap_function_wrapper(InstrumentedClient, "__init__", init)
-        wrapt.wrap_function_wrapper(InstrumentedConsumer, "__init__", init)
-        wrapt.wrap_function_wrapper(InstrumentedProducer, "__init__", init)
+        wrapt.wrap_function_wrapper(_InstrumentedClient, "__init__", init)
+        wrapt.wrap_function_wrapper(_InstrumentedConsumer, "__init__", init)
+        wrapt.wrap_function_wrapper(_InstrumentedProducer, "__init__", init)
 
     def _uninstrument(self, **kwargs):
         pulsar.Client = self._original_pulsar_client
         pulsar.Producer = self._original_pulsar_producer
         pulsar.Consumer = self._original_pulsar_consumer
         pulsar.Message = self._original_pulsar_message
 
-        unwrap(InstrumentedClient, "__init__")
-        unwrap(InstrumentedConsumer, "__init__")
-        unwrap(InstrumentedProducer, "__init__")
+        unwrap(_InstrumentedClient, "__init__")
+        unwrap(_InstrumentedConsumer, "__init__")
+        unwrap(_InstrumentedProducer, "__init__")
+
+
+__all__ = (PulsarInstrumentor,)

instrumentation/opentelemetry-instrumentation-pulsar/src/opentelemetry/instrumentation/pulsar/utils.py

@@ -1,7 +1,20 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 from typing import Optional
 
 import pulsar
-
 from opentelemetry.semconv.trace import (
     MessagingDestinationKindValues,
     MessagingOperationValues,

instrumentation/opentelemetry-instrumentation-pulsar/tests/test_instrumentation.py

@@ -17,11 +17,11 @@
 from unittest import TestCase
 
 from opentelemetry.instrumentation.pulsar import (
-    InstrumentedClient,
-    InstrumentedConsumer,
-    InstrumentedMessage,
-    InstrumentedProducer,
     PulsarInstrumentor,
+    _InstrumentedClient,
+    _InstrumentedConsumer,
+    _InstrumentedMessage,
+    _InstrumentedProducer,
 )
 
 
@@ -34,13 +34,13 @@ def test_instrument_api(self) -> None:
 
         client = Client("pulsar+ssl://localhost")
 
-        self.assertEqual(client.__class__, InstrumentedClient)
+        self.assertEqual(client.__class__, _InstrumentedClient)
         producer = Producer()
 
-        self.assertEqual(producer.__class__, InstrumentedProducer)
+        self.assertEqual(producer.__class__, _InstrumentedProducer)
 
         consumer = Consumer()
-        self.assertEqual(consumer.__class__, InstrumentedConsumer)
+        self.assertEqual(consumer.__class__, _InstrumentedConsumer)
 
         message = Message()
-        self.assertEqual(message.__class__, InstrumentedMessage)
+        self.assertEqual(message.__class__, _InstrumentedMessage)