Instrumenting Redis

dev-requirements.txt

@@ -7,4 +7,4 @@ sphinx~=2.1
 sphinx-rtd-theme~=0.4
 sphinx-autodoc-typehints~=1.10.2
 pytest!=5.2.3
-pytest-cov>=2.8
+pytest-cov>=2.8

docker-compose.yml

@@ -0,0 +1,8 @@
+version: "3"
+# remember to use this compose file __ONLY__ for development/testing purposes
+
+services:
+    redis:
+        image: redis:4.0-alpine
+        ports:
+            - "127.0.0.1:6379:6379"

instrumentation/opentelemetry-instrumentation-redis/README.rst

@@ -0,0 +1,23 @@
+OpenTelemetry Redis Instrumentation
+===================================
+
+|pypi|
+
+.. |pypi| image:: https://badge.fury.io/py/opentelemetry-instrumentation-redis.svg
+   :target: https://pypi.org/project/opentelemetry-instrumentation-redis/
+
+This library allows tracing requests made by the Redis library.
+
+Installation
+------------
+
+::
+
+    pip install opentelemetry-instrumentation-redis
+
+
+References
+----------
+
+* `OpenTelemetry Redis Instrumentation <https://opentelemetry-python.readthedocs.io/en/latest/instrumentation/opentelemetry-instrumentation-redis/opentelemetry-instrumentation-redis.html>`_
+* `OpenTelemetry Project <https://opentelemetry.io/>`_

instrumentation/opentelemetry-instrumentation-redis/setup.cfg

@@ -0,0 +1,53 @@
+# 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.
+#
+[metadata]
+name = opentelemetry-instrumentation-redis
+description = Redis tracing for OpenTelemetry
+long_description = file: README.rst
+long_description_content_type = text/x-rst
+author = OpenTelemetry Authors
+author_email = [email protected]
+url = https://github.com/open-telemetry/opentelemetry-python-contrib/instrumentation/opentelemetry-instrumentation-redis
+platforms = any
+license = Apache-2.0
+classifiers =
+    Development Status :: 4 - Beta
+    Intended Audience :: Developers
+    License :: OSI Approved :: Apache Software License
+    Programming Language :: Python
+    Programming Language :: Python :: 3
+    Programming Language :: Python :: 3.4
+    Programming Language :: Python :: 3.5
+    Programming Language :: Python :: 3.6
+    Programming Language :: Python :: 3.7
+    Programming Language :: Python :: 3.8
+
+[options]
+python_requires = >=3.4
+package_dir=
+    =src
+packages=find_namespace:
+install_requires =
+    # pin versions
+    wrapt
+    opentelemetry-api
+    opentelemetry-sdk
+
+[options.extras_require]
+test =
+    redis
+
+[options.packages.find]
+where = src

instrumentation/opentelemetry-instrumentation-redis/setup.py

@@ -0,0 +1,33 @@
+# 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.
+import os
+
+import setuptools
+
+BASE_DIR = os.path.dirname(__file__)
+VERSION_FILENAME = os.path.join(
+    BASE_DIR, "src", "opentelemetry", "instrumentation", "redis", "version.py"
+)
+PACKAGE_INFO = {}
+with open(VERSION_FILENAME) as f:
+    exec(f.read(), PACKAGE_INFO)
+
+setuptools.setup(
+    version=PACKAGE_INFO["__version__"],
+    entry_points={
+        "opentelemetry_instrumentor": [
+            "redis = opentelemetry.instrumentation.redis:RedisInstrumentor"
+        ]
+    },
+)

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

@@ -0,0 +1,43 @@
+# 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.
+#
+"""Instrument redis to report Redis queries.
+
+opentelemetry-auto-instrumentation will automatically patch your Redis client to make it work.
+::
+
+    from opentelemetry.instrumentation.redis.patch import patch
+    import redis
+
+    # If not patched yet, you can patch redis specifically
+    patch(redis=True)
+
+    # This will report a span with the default settings
+    client = redis.StrictRedis(host="localhost", port=6379)
+    client.get("my-key")
+"""
+from opentelemetry.auto_instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.redis.patch import patch, unpatch
+
+
+class RedisInstrumentor(BaseInstrumentor):
+    """An instrumentor for Redis
+    See `BaseInstrumentor`
+    """
+
+    def _instrument(self):
+        patch()
+
+    def _uninstrument(self):
+        unpatch()

instrumentation/opentelemetry-instrumentation-redis/src/opentelemetry/instrumentation/redis/constants.py

@@ -0,0 +1,28 @@
+# 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.
+#
+
+# defaults
+APP = "redis"
+DEFAULT_SERVICE = "redis"
+
+# net extension
+DB = "out.redis_db"
+
+# standard tags
+RAWCMD = "redis.raw_command"
+CMD = "redis.command"
+ARGS_LEN = "redis.args_length"
+PIPELINE_LEN = "redis.pipeline_length"
+PIPELINE_AGE = "redis.pipeline_age"

instrumentation/opentelemetry-instrumentation-redis/src/opentelemetry/instrumentation/redis/patch.py

@@ -0,0 +1,132 @@
+# 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.
+#
+# pylint:disable=relative-beyond-top-level
+import redis
+import wrapt
+
+from opentelemetry import trace
+from opentelemetry.instrumentation.redis import constants
+
+from .util import _extract_conn_attributes, format_command_args
+from .version import __version__
+
+
+def patch():
+    """Patch the instrumented methods
+
+    This duplicated doesn't look nice. The nicer alternative is to use an ObjectProxy on top
+    of Redis and StrictRedis. However, it means that any "import redis.Redis" won't be instrumented.
+    """
+    if getattr(redis, "_opentelemetry_patch", False):
+        return
+    setattr(redis, "_opentelemetry_patch", True)
+
+    _w = wrapt.wrap_function_wrapper
+    if redis.VERSION < (3, 0, 0):
+        _w("redis", "StrictRedis.execute_command", traced_execute_command)
+        _w("redis", "StrictRedis.pipeline", traced_pipeline)
+        _w("redis", "Redis.pipeline", traced_pipeline)
+        _w("redis.client", "BasePipeline.execute", traced_execute_pipeline)
+        _w(
+            "redis.client",
+            "BasePipeline.immediate_execute_command",
+            traced_execute_command,
+        )
+    else:
+        _w("redis", "Redis.execute_command", traced_execute_command)
+        _w("redis", "Redis.pipeline", traced_pipeline)
+        _w("redis.client", "Pipeline.execute", traced_execute_pipeline)
+        _w(
+            "redis.client",
+            "Pipeline.immediate_execute_command",
+            traced_execute_command,
+        )
+
+
+def unwrap(obj, attr):
+    func = getattr(obj, attr, None)
+    if (
+        func
+        and isinstance(func, wrapt.ObjectProxy)
+        and hasattr(func, "__wrapped__")
+    ):
+        setattr(obj, attr, func.__wrapped__)
+
+
+def unpatch():
+    if getattr(redis, "_opentelemetry_patch", False):
+        setattr(redis, "_opentelemetry_patch", False)
+        print("unpatch")
+        if redis.VERSION < (3, 0, 0):
+            unwrap(redis.StrictRedis, "execute_command")
+            unwrap(redis.StrictRedis, "pipeline")
+            unwrap(redis.Redis, "pipeline")
+            unwrap(
+                redis.client.BasePipeline,  # pylint:disable=no-member
+                "execute",
+            )
+            unwrap(
+                redis.client.BasePipeline,  # pylint:disable=no-member
+                "immediate_execute_command",
+            )
+        else:
+            print("unwrapping")
+            unwrap(redis.Redis, "execute_command")
+            unwrap(redis.Redis, "pipeline")
+            unwrap(redis.client.Pipeline, "execute")
+            unwrap(redis.client.Pipeline, "immediate_execute_command")
+
+
+#
+# tracing functions
+#
+def traced_execute_command(func, instance, args, kwargs):
+    tracer = trace.get_tracer(constants.DEFAULT_SERVICE, __version__)
+
+    with tracer.start_as_current_span(constants.CMD) as span:
+        span.set_attribute("service", tracer.instrumentation_info.name)
+        query = format_command_args(args)
+        span.set_attribute(constants.RAWCMD, query)
+        for key, value in _get_attributes(instance).items():
+            span.set_attribute(key, value)
+        # TODO: set metric
+        # s.set_metric(ARGS_LEN, len(args))
+        return func(*args, **kwargs)
+
+
+# pylint: disable=unused-argument
+def traced_pipeline(func, instance, args, kwargs):
+    return func(*args, **kwargs)
+
+
+def traced_execute_pipeline(func, instance, args, kwargs):
+    tracer = trace.get_tracer(constants.DEFAULT_SERVICE, __version__)
+
+    # FIXME[matt] done in the agent. worth it?
+    cmds = [format_command_args(c) for c, _ in instance.command_stack]
+    resource = "\n".join(cmds)
+
+    with tracer.start_as_current_span(constants.CMD) as span:
+        span.set_attribute("service", tracer.instrumentation_info.name)
+        span.set_attribute(constants.RAWCMD, resource)
+        for key, value in _get_attributes(instance).items():
+            span.set_attribute(key, value)
+        # TODO: set metric
+        # s.set_metric(PIPELINE_LEN, len(instance.command_stack))
+        return func(*args, **kwargs)
+
+
+def _get_attributes(conn):
+    return _extract_conn_attributes(conn.connection_pool.connection_kwargs)