Context API

This change implements the Context API portion of OTEP open-telemetry#66. The CorrelationContext API and Propagation API changes will come in future PRs. We're leveraging entrypoints to support other implementations of the Context API if/when necessary. For backwards compatibility, this change uses aiocontextvars for Python versions older than 3.7.

Signed-off-by: Alex Boten <[email protected]>

Author: Alex Boten

ext/opentelemetry-ext-http-requests/src/opentelemetry/ext/http_requests/__init__.py

@@ -23,7 +23,7 @@
 from requests.sessions import Session
 
 from opentelemetry import propagators
-from opentelemetry.context import Context
+from opentelemetry.context import get_value
 from opentelemetry.ext.http_requests.version import __version__
 from opentelemetry.trace import SpanKind
 
@@ -54,7 +54,7 @@ def enable(tracer_source):
 
     @functools.wraps(wrapped)
     def instrumented_request(self, method, url, *args, **kwargs):
-        if Context.suppress_instrumentation:
+        if get_value("suppress_instrumentation"):
             return wrapped(self, method, url, *args, **kwargs)
 
         # See

opentelemetry-api/setup.py

@@ -56,4 +56,10 @@
         "/tree/master/opentelemetry-api"
     ),
     zip_safe=False,
+    entry_points={
+        "opentelemetry_context": [
+            "default_context = "
+            "opentelemetry.context.default_context:DefaultContext",
+        ]
+    },
 )

opentelemetry-api/src/opentelemetry/context/__init__.py

@@ -12,141 +12,68 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import typing
+from os import environ
 
-"""
-The OpenTelemetry context module provides abstraction layer on top of
-thread-local storage and contextvars. The long term direction is to switch to
-contextvars provided by the Python runtime library.
-
-A global object ``Context`` is provided to access all the context related
-functionalities::
-
-    >>> from opentelemetry.context import Context
-    >>> Context.foo = 1
-    >>> Context.foo = 2
-    >>> Context.foo
-    2
-
-When explicit thread is used, a helper function
-``Context.with_current_context`` can be used to carry the context across
-threads::
-
-    from threading import Thread
-    from opentelemetry.context import Context
-
-    def work(name):
-        print('Entering worker:', Context)
-        Context.operation_id = name
-        print('Exiting worker:', Context)
-
-    if __name__ == '__main__':
-        print('Main thread:', Context)
-        Context.operation_id = 'main'
-
-        print('Main thread:', Context)
-
-        # by default context is not propagated to worker thread
-        thread = Thread(target=work, args=('foo',))
-        thread.start()
-        thread.join()
-
-        print('Main thread:', Context)
-
-        # user can propagate context explicitly
-        thread = Thread(
-            target=Context.with_current_context(work),
-            args=('bar',),
-        )
-        thread.start()
-        thread.join()
-
-        print('Main thread:', Context)
-
-Here goes another example using thread pool::
-
-    import time
-    import threading
-
-    from multiprocessing.dummy import Pool as ThreadPool
-    from opentelemetry.context import Context
-
-    _console_lock = threading.Lock()
-
-    def println(msg):
-        with _console_lock:
-            print(msg)
-
-    def work(name):
-        println('Entering worker[{}]: {}'.format(name, Context))
-        Context.operation_id = name
-        time.sleep(0.01)
-        println('Exiting worker[{}]: {}'.format(name, Context))
-
-    if __name__ == "__main__":
-        println('Main thread: {}'.format(Context))
-        Context.operation_id = 'main'
-        pool = ThreadPool(2)  # create a thread pool with 2 threads
-        pool.map(Context.with_current_context(work), [
-            'bear',
-            'cat',
-            'dog',
-            'horse',
-            'rabbit',
-        ])
-        pool.close()
-        pool.join()
-        println('Main thread: {}'.format(Context))
-
-Here goes a simple demo of how async could work in Python 3.7+::
-
-    import asyncio
-
-    from opentelemetry.context import Context
-
-    class Span(object):
-        def __init__(self, name):
-            self.name = name
-            self.parent = Context.current_span
-
-        def __repr__(self):
-            return ('{}(name={}, parent={})'
-                    .format(
-                        type(self).__name__,
-                        self.name,
-                        self.parent,
-                    ))
-
-        async def __aenter__(self):
-            Context.current_span = self
-
-        async def __aexit__(self, exc_type, exc, tb):
-            Context.current_span = self.parent
-
-    async def main():
-        print(Context)
-        async with Span('foo'):
-            print(Context)
-            await asyncio.sleep(0.1)
-            async with Span('bar'):
-                print(Context)
-                await asyncio.sleep(0.1)
-            print(Context)
-            await asyncio.sleep(0.1)
-        print(Context)
-
-    if __name__ == '__main__':
-        asyncio.run(main())
-"""
-
-from .base_context import BaseRuntimeContext
-
-__all__ = ["Context"]
-
-try:
-    from .async_context import AsyncRuntimeContext
-
-    Context = AsyncRuntimeContext()  # type: BaseRuntimeContext
-except ImportError:
-    from .thread_local_context import ThreadLocalRuntimeContext
-
-    Context = ThreadLocalRuntimeContext()
+from pkg_resources import iter_entry_points
+
+from opentelemetry.context.context import Context
+
+# FIXME use a better implementation of a configuration manager to avoid having
+# to get configuration values straight from environment variables
+_CONTEXT = {
+    entry_point.name: entry_point.load()
+    for entry_point in (iter_entry_points("opentelemetry_context"))
+}[
+    environ.get("OPENTELEMETRY_CONTEXT", "default_context")
+]()  # type: Context
+
+
+def _copy_context(context: typing.Optional[Context]) -> Context:
+    if context:
+        return context.copy()
+    return get_current().copy()
+
+
+def create_key(key: str) -> "object":
+    # FIXME Implement this
+    raise NotImplementedError
+
+
+def get_value(key: str, context: typing.Optional[Context] = None) -> "object":
+    if context:
+        return context.get_value(key)
+    return get_current().get_value(key)
+
+
+def set_value(
+    key: str, value: "object", context: typing.Optional[Context] = None
+) -> Context:
+    new_context = _copy_context(context)
+    new_context.set_value(key, value)
+    return new_context
+
+
+def remove_value(context: Context, key: str) -> Context:
+    new_context = _copy_context(context)
+    new_context.remove_value(key)
+    return new_context
+
+
+def get_current() -> Context:
+    return _CONTEXT
+
+
+def set_current(context: Context) -> None:
+    global _CONTEXT
+    _CONTEXT = context
+
+
+__all__ = [
+    "get_value",
+    "set_value",
+    "remove_value",
+    "get_current",
+    "set_current",
+    "Context",
+]