Test PR

.flake8

@@ -18,3 +18,4 @@ exclude =
   ext/opentelemetry-ext-jaeger/src/opentelemetry/ext/jaeger/gen/
   ext/opentelemetry-ext-jaeger/build/*
   docs/examples/opentelemetry-example-app/src/opentelemetry_example_app/grpc/gen/
+  docs/examples/opentelemetry-example-app/build/*

.isort.cfg

@@ -15,4 +15,4 @@ multi_line_output=3
 skip=target
 skip_glob=**/gen/*,.venv*/*,venv*/*
 known_first_party=opentelemetry,opentelemetry_example_app
-known_third_party=psutil,pytest
+known_third_party=psutil,pytest,redis,redis_opentracing

.travis.yml

@@ -5,12 +5,12 @@ language: python
 cache: pip
 
 python:
+  - 'pypy3'
+  - '3.8'
   - '3.4'
   - '3.5'
   - '3.6'
   - '3.7'
-  - '3.8'
-  - 'pypy3'
 
 #matrix:
 #  allow_failures:

dev-requirements.txt

@@ -1,4 +1,4 @@
-pylint~=2.3
+pylint==2.4.4
 flake8~=3.7
 isort~=4.3
 black>=19.3b0,==19.*

docs/examples/http/client.py

@@ -28,15 +28,18 @@
 
 # The preferred tracer implementation must be set, as the opentelemetry-api
 # defines the interface with a no-op implementation.
+# It must be done before instrumenting any library.
 trace.set_tracer_provider(TracerProvider())
-tracer_provider = trace.get_tracer_provider()
 
+# Enable instrumentation in the requests library.
+http_requests.RequestsInstrumentor().instrument()
+
+# Configure a console span exporter.
 exporter = ConsoleSpanExporter()
 span_processor = BatchExportSpanProcessor(exporter)
-tracer_provider.add_span_processor(span_processor)
+trace.get_tracer_provider().add_span_processor(span_processor)
 
 # Integrations are the glue that binds the OpenTelemetry API and the
 # frameworks and libraries that are used together, automatically creating
 # Spans and propagating context as appropriate.
-http_requests.enable(tracer_provider)
 response = requests.get(url="http://127.0.0.1:5000/")

docs/examples/http/server.py

@@ -30,20 +30,23 @@
 
 # The preferred tracer implementation must be set, as the opentelemetry-api
 # defines the interface with a no-op implementation.
+# It must be done before instrumenting any library.
 trace.set_tracer_provider(TracerProvider())
-tracer = trace.get_tracer(__name__)
-
-exporter = ConsoleSpanExporter()
-span_processor = BatchExportSpanProcessor(exporter)
-trace.get_tracer_provider().add_span_processor(span_processor)
 
 # Integrations are the glue that binds the OpenTelemetry API and the
 # frameworks and libraries that are used together, automatically creating
 # Spans and propagating context as appropriate.
-http_requests.enable(trace.get_tracer_provider())
+http_requests.RequestsInstrumentor().instrument()
 app = flask.Flask(__name__)
 app.wsgi_app = OpenTelemetryMiddleware(app.wsgi_app)
 
+# Configure a console span exporter.
+exporter = ConsoleSpanExporter()
+span_processor = BatchExportSpanProcessor(exporter)
+trace.get_tracer_provider().add_span_processor(span_processor)
+
+tracer = trace.get_tracer(__name__)
+
 
 @app.route("/")
 def hello():

docs/examples/opentelemetry-example-app/src/opentelemetry_example_app/flask_example.py

@@ -28,14 +28,20 @@
     SimpleExportSpanProcessor,
 )
 
+# The preferred tracer implementation must be set, as the opentelemetry-api
+# defines the interface with a no-op implementation.
+# It must be done before instrumenting any library
 trace.set_tracer_provider(TracerProvider())
+
+opentelemetry.ext.http_requests.RequestsInstrumentor().instrument()
+FlaskInstrumentor().instrument()
+
 trace.get_tracer_provider().add_span_processor(
     SimpleExportSpanProcessor(ConsoleSpanExporter())
 )
 
-FlaskInstrumentor().instrument()
+
 app = flask.Flask(__name__)
-opentelemetry.ext.http_requests.enable(trace.get_tracer_provider())
 
 
 @app.route("/")

docs/ext/redis/redis.rst

@@ -0,0 +1,7 @@
+OpenTelemetry Redis Instrumentation
+===================================
+
+.. automodule:: opentelemetry.ext.redis
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/ext/sqlalchemy/sqlalchemy.rst

@@ -0,0 +1,7 @@
+OpenTelemetry SQLAlchemy Instrumentation
+========================================
+
+.. automodule:: opentelemetry.ext.sqlalchemy
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/getting-started.rst

@@ -202,7 +202,7 @@ And let's write a small Flask application that sends an HTTP request, activating
     )
 
     app = flask.Flask(__name__)
-    opentelemetry.ext.http_requests.enable(trace.get_tracer_provider())
+    opentelemetry.ext.http_requests.RequestsInstrumentor().instrument()
 
     @app.route("/")
     def hello():

eachdist.ini

@@ -6,6 +6,7 @@ sortfirst=
     opentelemetry-sdk
     opentelemetry-auto-instrumentation
     ext/opentelemetry-ext-wsgi
+    ext/opentelemetry-ext-dbapi
     ext/*
 
 [lintroots]

ext/opentelemetry-ext-docker-tests/tests/check_availability.py

@@ -18,6 +18,7 @@
 import mysql.connector
 import psycopg2
 import pymongo
+import redis
 
 MONGODB_COLLECTION_NAME = "test"
 MONGODB_DB_NAME = os.getenv("MONGODB_DB_NAME", "opentelemetry-tests")
@@ -33,76 +34,82 @@
 POSTGRES_PASSWORD = os.getenv("POSTGRESQL_HOST", "testpassword")
 POSTGRES_PORT = int(os.getenv("POSTGRESQL_PORT", "5432"))
 POSTGRES_USER = os.getenv("POSTGRESQL_HOST", "testuser")
+REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
+REDIS_PORT = int(os.getenv("REDIS_PORT ", "6379"))
 RETRY_COUNT = 5
 RETRY_INTERVAL = 5  # Seconds
 
 logger = logging.getLogger(__name__)
 
 
+def retryable(func):
+    def wrapper():
+        # Try to connect to DB
+        for i in range(RETRY_COUNT):
+            try:
+                func()
+                return
+            except Exception as ex:  # pylint: disable=broad-except
+                logger.error(
+                    "waiting for %s, retry %d/%d [%s]",
+                    func.__name__,
+                    i + 1,
+                    RETRY_COUNT,
+                    ex,
+                )
+            time.sleep(RETRY_INTERVAL)
+        raise Exception("waiting for {} failed".format(func.__name__))
+
+    return wrapper
+
+
+@retryable
 def check_pymongo_connection():
-    # Try to connect to DB
-    for i in range(RETRY_COUNT):
-        try:
-            client = pymongo.MongoClient(
-                MONGODB_HOST, MONGODB_PORT, serverSelectionTimeoutMS=2000
-            )
-            db = client[MONGODB_DB_NAME]
-            collection = db[MONGODB_COLLECTION_NAME]
-            collection.find_one()
-            client.close()
-            break
-        except Exception as ex:
-            if i == RETRY_COUNT - 1:
-                raise (ex)
-            logger.exception(ex)
-        time.sleep(RETRY_INTERVAL)
+    client = pymongo.MongoClient(
+        MONGODB_HOST, MONGODB_PORT, serverSelectionTimeoutMS=2000
+    )
+    db = client[MONGODB_DB_NAME]
+    collection = db[MONGODB_COLLECTION_NAME]
+    collection.find_one()
+    client.close()
 
 
+@retryable
 def check_mysql_connection():
-    # Try to connect to DB
-    for i in range(RETRY_COUNT):
-        try:
-            connection = mysql.connector.connect(
-                user=MYSQL_USER,
-                password=MYSQL_PASSWORD,
-                host=MYSQL_HOST,
-                port=MYSQL_PORT,
-                database=MYSQL_DB_NAME,
-            )
-            connection.close()
-            break
-        except Exception as ex:
-            if i == RETRY_COUNT - 1:
-                raise (ex)
-            logger.exception(ex)
-        time.sleep(RETRY_INTERVAL)
+    connection = mysql.connector.connect(
+        user=MYSQL_USER,
+        password=MYSQL_PASSWORD,
+        host=MYSQL_HOST,
+        port=MYSQL_PORT,
+        database=MYSQL_DB_NAME,
+    )
+    connection.close()
 
 
+@retryable
 def check_postgres_connection():
-    # Try to connect to DB
-    for i in range(RETRY_COUNT):
-        try:
-            connection = psycopg2.connect(
-                dbname=POSTGRES_DB_NAME,
-                user=POSTGRES_USER,
-                password=POSTGRES_PASSWORD,
-                host=POSTGRES_HOST,
-                port=POSTGRES_PORT,
-            )
-            connection.close()
-            break
-        except Exception as ex:
-            if i == RETRY_COUNT - 1:
-                raise (ex)
-            logger.exception(ex)
-        time.sleep(RETRY_INTERVAL)
+    connection = psycopg2.connect(
+        dbname=POSTGRES_DB_NAME,
+        user=POSTGRES_USER,
+        password=POSTGRES_PASSWORD,
+        host=POSTGRES_HOST,
+        port=POSTGRES_PORT,
+    )
+    connection.close()
+
+
+@retryable
+def check_redis_connection():
+    connection = redis.Redis(host=REDIS_HOST, port=REDIS_PORT)
+    connection.hgetall("*")
 
 
 def check_docker_services_availability():
     # Check if Docker services accept connections
     check_pymongo_connection()
     check_mysql_connection()
     check_postgres_connection()
+    check_redis_connection()
 
 
 check_docker_services_availability()

ext/opentelemetry-ext-docker-tests/tests/docker-compose.yml

@@ -23,4 +23,8 @@ services:
       POSTGRES_USER: testuser
       POSTGRES_PASSWORD: testpassword
       POSTGRES_DB: opentelemetry-tests
+  otredis:
+      image: redis:4.0-alpine
+      ports:
+          - "127.0.0.1:6379:6379"
 

ext/opentelemetry-ext-docker-tests/tests/pymongo/test_pymongo_functional.py

@@ -17,7 +17,7 @@
 from pymongo import MongoClient
 
 from opentelemetry import trace as trace_api
-from opentelemetry.ext.pymongo import trace_integration
+from opentelemetry.ext.pymongo import PymongoInstrumentor
 from opentelemetry.test.test_base import TestBase
 
 MONGODB_HOST = os.getenv("MONGODB_HOST ", "localhost")
@@ -31,7 +31,7 @@ class TestFunctionalPymongo(TestBase):
     def setUpClass(cls):
         super().setUpClass()
         cls._tracer = cls.tracer_provider.get_tracer(__name__)
-        trace_integration(cls.tracer_provider)
+        PymongoInstrumentor().instrument()
         client = MongoClient(
             MONGODB_HOST, MONGODB_PORT, serverSelectionTimeoutMS=2000
         )
@@ -94,3 +94,23 @@ def test_delete(self):
         with self._tracer.start_as_current_span("rootSpan"):
             self._collection.delete_one({"name": "testName"})
         self.validate_spans()
+
+    def test_uninstrument(self):
+        # check that integration is working
+        self._collection.find_one()
+        spans = self.memory_exporter.get_finished_spans()
+        self.memory_exporter.clear()
+        self.assertEqual(len(spans), 1)
+
+        # uninstrument and check not new spans are created
+        PymongoInstrumentor().uninstrument()
+        self._collection.find_one()
+        spans = self.memory_exporter.get_finished_spans()
+        self.memory_exporter.clear()
+        self.assertEqual(len(spans), 0)
+
+        # re-enable and check that it works again
+        PymongoInstrumentor().instrument()
+        self._collection.find_one()
+        spans = self.memory_exporter.get_finished_spans()
+        self.assertEqual(len(spans), 1)