TUN-528: Move cloudflared into a separate repo

vendor/github.com/grpc-ecosystem/grpc-opentracing/python/grpc_opentracing/__init__.py

@@ -0,0 +1,96 @@
+import abc
+import enum
+
+import six
+
+import grpc
+
+
+class ActiveSpanSource(six.with_metaclass(abc.ABCMeta)):
+    """Provides a way to access an the active span."""
+
+    @abc.abstractmethod
+    def get_active_span(self):
+        """Identifies the active span.
+
+    Returns:
+      An object that implements the opentracing.Span interface.
+    """
+        raise NotImplementedError()
+
+
+class RpcInfo(six.with_metaclass(abc.ABCMeta)):
+    """Provides information for an RPC call.
+
+  Attributes:
+    full_method: A string of the full RPC method, i.e., /package.service/method.
+    metadata: The initial :term:`metadata`.
+    timeout: The length of time in seconds to wait for the computation to
+      terminate or be cancelled.
+    request: The RPC request or None for request-streaming RPCs.
+    response: The RPC response or None for response-streaming or erroring RPCs.
+    error: The RPC error or None for successful RPCs.
+  """
+
+
+class SpanDecorator(six.with_metaclass(abc.ABCMeta)):
+    """Provides a mechanism to add arbitrary tags/logs/etc to the
+    opentracing.Span associated with client and/or server RPCs."""
+
+    @abc.abstractmethod
+    def __call__(self, span, rpc_info):
+        """Customizes an RPC span.
+
+    Args:
+      span: The client-side or server-side opentracing.Span for the RPC.
+      rpc_info: An RpcInfo describing the RPC.
+    """
+        raise NotImplementedError()
+
+
+def open_tracing_client_interceptor(tracer,
+                                    active_span_source=None,
+                                    log_payloads=False,
+                                    span_decorator=None):
+    """Creates an invocation-side interceptor that can be use with gRPC to add
+    OpenTracing information.
+
+  Args:
+    tracer: An object implmenting the opentracing.Tracer interface.
+    active_span_source: An optional ActiveSpanSource to customize how the
+      active span is determined.
+    log_payloads: Indicates whether requests should be logged.
+    span_decorator: An optional SpanDecorator.
+
+  Returns:
+    An invocation-side interceptor object.
+  """
+    from grpc_opentracing import _client
+    return _client.OpenTracingClientInterceptor(tracer, active_span_source,
+                                                log_payloads, span_decorator)
+
+
+def open_tracing_server_interceptor(tracer,
+                                    log_payloads=False,
+                                    span_decorator=None):
+    """Creates a service-side interceptor that can be use with gRPC to add
+    OpenTracing information.
+
+  Args:
+    tracer: An object implmenting the opentracing.Tracer interface.
+    log_payloads: Indicates whether requests should be logged.
+    span_decorator: An optional SpanDecorator.
+
+  Returns:
+    A service-side interceptor object.
+  """
+    from grpc_opentracing import _server
+    return _server.OpenTracingServerInterceptor(tracer, log_payloads,
+                                                span_decorator)
+
+
+###################################  __all__  #################################
+
+__all__ = ('ActiveSpanSource', 'RpcInfo', 'SpanDecorator',
+           'open_tracing_client_interceptor',
+           'open_tracing_server_interceptor',)

vendor/github.com/grpc-ecosystem/grpc-opentracing/python/grpc_opentracing/_client.py

@@ -0,0 +1,209 @@
+"""Implementation of the invocation-side open-tracing interceptor."""
+
+import sys
+import logging
+import time
+
+from six import iteritems
+
+import grpc
+from grpc_opentracing import grpcext
+from grpc_opentracing._utilities import get_method_type, get_deadline_millis,\
+    log_or_wrap_request_or_iterator, RpcInfo
+import opentracing
+from opentracing.ext import tags as ot_tags
+
+
+class _GuardedSpan(object):
+
+    def __init__(self, span):
+        self.span = span
+        self._engaged = True
+
+    def __enter__(self):
+        self.span.__enter__()
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        if self._engaged:
+            return self.span.__exit__(*args, **kwargs)
+        else:
+            return False
+
+    def release(self):
+        self._engaged = False
+        return self.span
+
+
+def _inject_span_context(tracer, span, metadata):
+    headers = {}
+    try:
+        tracer.inject(span.context, opentracing.Format.HTTP_HEADERS, headers)
+    except (opentracing.UnsupportedFormatException,
+            opentracing.InvalidCarrierException,
+            opentracing.SpanContextCorruptedException) as e:
+        logging.exception('tracer.inject() failed')
+        span.log_kv({'event': 'error', 'error.object': e})
+        return metadata
+    metadata = () if metadata is None else tuple(metadata)
+    return metadata + tuple(iteritems(headers))
+
+
+def _make_future_done_callback(span, rpc_info, log_payloads, span_decorator):
+
+    def callback(response_future):
+        with span:
+            code = response_future.code()
+            if code != grpc.StatusCode.OK:
+                span.set_tag('error', True)
+                error_log = {'event': 'error', 'error.kind': str(code)}
+                details = response_future.details()
+                if details is not None:
+                    error_log['message'] = details
+                span.log_kv(error_log)
+                rpc_info.error = code
+                if span_decorator is not None:
+                    span_decorator(span, rpc_info)
+                return
+            response = response_future.result()
+            rpc_info.response = response
+            if log_payloads:
+                span.log_kv({'response': response})
+            if span_decorator is not None:
+                span_decorator(span, rpc_info)
+
+    return callback
+
+
+class OpenTracingClientInterceptor(grpcext.UnaryClientInterceptor,
+                                   grpcext.StreamClientInterceptor):
+
+    def __init__(self, tracer, active_span_source, log_payloads,
+                 span_decorator):
+        self._tracer = tracer
+        self._active_span_source = active_span_source
+        self._log_payloads = log_payloads
+        self._span_decorator = span_decorator
+
+    def _start_span(self, method):
+        active_span_context = None
+        if self._active_span_source is not None:
+            active_span = self._active_span_source.get_active_span()
+            if active_span is not None:
+                active_span_context = active_span.context
+        tags = {
+            ot_tags.COMPONENT: 'grpc',
+            ot_tags.SPAN_KIND: ot_tags.SPAN_KIND_RPC_CLIENT
+        }
+        return self._tracer.start_span(
+            operation_name=method, child_of=active_span_context, tags=tags)
+
+    def _trace_result(self, guarded_span, rpc_info, result):
+        # If the RPC is called asynchronously, release the guard and add a callback
+        # so that the span can be finished once the future is done.
+        if isinstance(result, grpc.Future):
+            result.add_done_callback(
+                _make_future_done_callback(guarded_span.release(
+                ), rpc_info, self._log_payloads, self._span_decorator))
+            return result
+        response = result
+        # Handle the case when the RPC is initiated via the with_call
+        # method and the result is a tuple with the first element as the
+        # response.
+        # http://www.grpc.io/grpc/python/grpc.html#grpc.UnaryUnaryMultiCallable.with_call
+        if isinstance(result, tuple):
+            response = result[0]
+        rpc_info.response = response
+        if self._log_payloads:
+            guarded_span.span.log_kv({'response': response})
+        if self._span_decorator is not None:
+            self._span_decorator(guarded_span.span, rpc_info)
+        return result
+
+    def _start_guarded_span(self, *args, **kwargs):
+        return _GuardedSpan(self._start_span(*args, **kwargs))
+
+    def intercept_unary(self, request, metadata, client_info, invoker):
+        with self._start_guarded_span(client_info.full_method) as guarded_span:
+            metadata = _inject_span_context(self._tracer, guarded_span.span,
+                                            metadata)
+            rpc_info = RpcInfo(
+                full_method=client_info.full_method,
+                metadata=metadata,
+                timeout=client_info.timeout,
+                request=request)
+            if self._log_payloads:
+                guarded_span.span.log_kv({'request': request})
+            try:
+                result = invoker(request, metadata)
+            except:
+                e = sys.exc_info()[0]
+                guarded_span.span.set_tag('error', True)
+                guarded_span.span.log_kv({'event': 'error', 'error.object': e})
+                rpc_info.error = e
+                if self._span_decorator is not None:
+                    self._span_decorator(guarded_span.span, rpc_info)
+                raise
+            return self._trace_result(guarded_span, rpc_info, result)
+
+    # For RPCs that stream responses, the result can be a generator. To record
+    # the span across the generated responses and detect any errors, we wrap the
+    # result in a new generator that yields the response values.
+    def _intercept_server_stream(self, request_or_iterator, metadata,
+                                 client_info, invoker):
+        with self._start_span(client_info.full_method) as span:
+            metadata = _inject_span_context(self._tracer, span, metadata)
+            rpc_info = RpcInfo(
+                full_method=client_info.full_method,
+                metadata=metadata,
+                timeout=client_info.timeout)
+            if client_info.is_client_stream:
+                rpc_info.request = request_or_iterator
+            if self._log_payloads:
+                request_or_iterator = log_or_wrap_request_or_iterator(
+                    span, client_info.is_client_stream, request_or_iterator)
+            try:
+                result = invoker(request_or_iterator, metadata)
+                for response in result:
+                    if self._log_payloads:
+                        span.log_kv({'response': response})
+                    yield response
+            except:
+                e = sys.exc_info()[0]
+                span.set_tag('error', True)
+                span.log_kv({'event': 'error', 'error.object': e})
+                rpc_info.error = e
+                if self._span_decorator is not None:
+                    self._span_decorator(span, rpc_info)
+                raise
+            if self._span_decorator is not None:
+                self._span_decorator(span, rpc_info)
+
+    def intercept_stream(self, request_or_iterator, metadata, client_info,
+                         invoker):
+        if client_info.is_server_stream:
+            return self._intercept_server_stream(request_or_iterator, metadata,
+                                                 client_info, invoker)
+        with self._start_guarded_span(client_info.full_method) as guarded_span:
+            metadata = _inject_span_context(self._tracer, guarded_span.span,
+                                            metadata)
+            rpc_info = RpcInfo(
+                full_method=client_info.full_method,
+                metadata=metadata,
+                timeout=client_info.timeout,
+                request=request_or_iterator)
+            if self._log_payloads:
+                request_or_iterator = log_or_wrap_request_or_iterator(
+                    guarded_span.span, client_info.is_client_stream,
+                    request_or_iterator)
+            try:
+                result = invoker(request_or_iterator, metadata)
+            except:
+                e = sys.exc_info()[0]
+                guarded_span.span.set_tag('error', True)
+                guarded_span.span.log_kv({'event': 'error', 'error.object': e})
+                rpc_info.error = e
+                if self._span_decorator is not None:
+                    self._span_decorator(guarded_span.span, rpc_info)
+                raise
+            return self._trace_result(guarded_span, rpc_info, result)

vendor/github.com/grpc-ecosystem/grpc-opentracing/python/grpc_opentracing/_server.py

@@ -0,0 +1,227 @@
+"""Implementation of the service-side open-tracing interceptor."""
+
+import sys
+import logging
+import re
+
+import grpc
+from grpc_opentracing import grpcext, ActiveSpanSource
+from grpc_opentracing._utilities import get_method_type, get_deadline_millis,\
+    log_or_wrap_request_or_iterator, RpcInfo
+import opentracing
+from opentracing.ext import tags as ot_tags
+
+
+class _OpenTracingServicerContext(grpc.ServicerContext, ActiveSpanSource):
+
+    def __init__(self, servicer_context, active_span):
+        self._servicer_context = servicer_context
+        self._active_span = active_span
+        self.code = grpc.StatusCode.OK
+        self.details = None
+
+    def is_active(self, *args, **kwargs):
+        return self._servicer_context.is_active(*args, **kwargs)
+
+    def time_remaining(self, *args, **kwargs):
+        return self._servicer_context.time_remaining(*args, **kwargs)
+
+    def cancel(self, *args, **kwargs):
+        return self._servicer_context.cancel(*args, **kwargs)
+
+    def add_callback(self, *args, **kwargs):
+        return self._servicer_context.add_callback(*args, **kwargs)
+
+    def invocation_metadata(self, *args, **kwargs):
+        return self._servicer_context.invocation_metadata(*args, **kwargs)
+
+    def peer(self, *args, **kwargs):
+        return self._servicer_context.peer(*args, **kwargs)
+
+    def peer_identities(self, *args, **kwargs):
+        return self._servicer_context.peer_identities(*args, **kwargs)
+
+    def peer_identity_key(self, *args, **kwargs):
+        return self._servicer_context.peer_identity_key(*args, **kwargs)
+
+    def auth_context(self, *args, **kwargs):
+        return self._servicer_context.auth_context(*args, **kwargs)
+
+    def send_initial_metadata(self, *args, **kwargs):
+        return self._servicer_context.send_initial_metadata(*args, **kwargs)
+
+    def set_trailing_metadata(self, *args, **kwargs):
+        return self._servicer_context.set_trailing_metadata(*args, **kwargs)
+
+    def set_code(self, code):
+        self.code = code
+        return self._servicer_context.set_code(code)
+
+    def set_details(self, details):
+        self.details = details
+        return self._servicer_context.set_details(details)
+
+    def get_active_span(self):
+        return self._active_span
+
+
+def _add_peer_tags(peer_str, tags):
+    ipv4_re = r"ipv4:(?P<address>.+):(?P<port>\d+)"
+    match = re.match(ipv4_re, peer_str)
+    if match:
+        tags[ot_tags.PEER_HOST_IPV4] = match.group('address')
+        tags[ot_tags.PEER_PORT] = match.group('port')
+        return
+    ipv6_re = r"ipv6:\[(?P<address>.+)\]:(?P<port>\d+)"
+    match = re.match(ipv6_re, peer_str)
+    if match:
+        tags[ot_tags.PEER_HOST_IPV6] = match.group('address')
+        tags[ot_tags.PEER_PORT] = match.group('port')
+        return
+    logging.warning('Unrecognized peer: \"%s\"', peer_str)
+
+
+# On the service-side, errors can be signaled either by exceptions or by calling
+# `set_code` on the `servicer_context`. This function checks for the latter and
+# updates the span accordingly.
+def _check_error_code(span, servicer_context, rpc_info):
+    if servicer_context.code != grpc.StatusCode.OK:
+        span.set_tag('error', True)
+        error_log = {'event': 'error', 'error.kind': str(servicer_context.code)}
+        if servicer_context.details is not None:
+            error_log['message'] = servicer_context.details
+        span.log_kv(error_log)
+        rpc_info.error = servicer_context.code
+
+
+class OpenTracingServerInterceptor(grpcext.UnaryServerInterceptor,
+                                   grpcext.StreamServerInterceptor):
+
+    def __init__(self, tracer, log_payloads, span_decorator):
+        self._tracer = tracer
+        self._log_payloads = log_payloads
+        self._span_decorator = span_decorator
+
+    def _start_span(self, servicer_context, method):
+        span_context = None
+        error = None
+        metadata = servicer_context.invocation_metadata()
+        try:
+            if metadata:
+                span_context = self._tracer.extract(
+                    opentracing.Format.HTTP_HEADERS, dict(metadata))
+        except (opentracing.UnsupportedFormatException,
+                opentracing.InvalidCarrierException,
+                opentracing.SpanContextCorruptedException) as e:
+            logging.exception('tracer.extract() failed')
+            error = e
+        tags = {
+            ot_tags.COMPONENT: 'grpc',
+            ot_tags.SPAN_KIND: ot_tags.SPAN_KIND_RPC_SERVER
+        }
+        _add_peer_tags(servicer_context.peer(), tags)
+        span = self._tracer.start_span(
+            operation_name=method, child_of=span_context, tags=tags)
+        if error is not None:
+            span.log_kv({'event': 'error', 'error.object': error})
+        return span
+
+    def intercept_unary(self, request, servicer_context, server_info, handler):
+        with self._start_span(servicer_context,
+                              server_info.full_method) as span:
+            rpc_info = RpcInfo(
+                full_method=server_info.full_method,
+                metadata=servicer_context.invocation_metadata(),
+                timeout=servicer_context.time_remaining(),
+                request=request)
+            if self._log_payloads:
+                span.log_kv({'request': request})
+            servicer_context = _OpenTracingServicerContext(
+                servicer_context, span)
+            try:
+                response = handler(request, servicer_context)
+            except:
+                e = sys.exc_info()[0]
+                span.set_tag('error', True)
+                span.log_kv({'event': 'error', 'error.object': e})
+                rpc_info.error = e
+                if self._span_decorator is not None:
+                    self._span_decorator(span, rpc_info)
+                raise
+            if self._log_payloads:
+                span.log_kv({'response': response})
+            _check_error_code(span, servicer_context, rpc_info)
+            rpc_info.response = response
+            if self._span_decorator is not None:
+                self._span_decorator(span, rpc_info)
+            return response
+
+    # For RPCs that stream responses, the result can be a generator. To record
+    # the span across the generated responses and detect any errors, we wrap the
+    # result in a new generator that yields the response values.
+    def _intercept_server_stream(self, request_or_iterator, servicer_context,
+                                 server_info, handler):
+        with self._start_span(servicer_context,
+                              server_info.full_method) as span:
+            rpc_info = RpcInfo(
+                full_method=server_info.full_method,
+                metadata=servicer_context.invocation_metadata(),
+                timeout=servicer_context.time_remaining())
+            if not server_info.is_client_stream:
+                rpc_info.request = request_or_iterator
+            if self._log_payloads:
+                request_or_iterator = log_or_wrap_request_or_iterator(
+                    span, server_info.is_client_stream, request_or_iterator)
+            servicer_context = _OpenTracingServicerContext(
+                servicer_context, span)
+            try:
+                result = handler(request_or_iterator, servicer_context)
+                for response in result:
+                    if self._log_payloads:
+                        span.log_kv({'response': response})
+                    yield response
+            except:
+                e = sys.exc_info()[0]
+                span.set_tag('error', True)
+                span.log_kv({'event': 'error', 'error.object': e})
+                rpc_info.error = e
+                if self._span_decorator is not None:
+                    self._span_decorator(span, rpc_info)
+                raise
+            _check_error_code(span, servicer_context, rpc_info)
+            if self._span_decorator is not None:
+                self._span_decorator(span, rpc_info)
+
+    def intercept_stream(self, request_or_iterator, servicer_context,
+                         server_info, handler):
+        if server_info.is_server_stream:
+            return self._intercept_server_stream(
+                request_or_iterator, servicer_context, server_info, handler)
+        with self._start_span(servicer_context,
+                              server_info.full_method) as span:
+            rpc_info = RpcInfo(
+                full_method=server_info.full_method,
+                metadata=servicer_context.invocation_metadata(),
+                timeout=servicer_context.time_remaining())
+            if self._log_payloads:
+                request_or_iterator = log_or_wrap_request_or_iterator(
+                    span, server_info.is_client_stream, request_or_iterator)
+            servicer_context = _OpenTracingServicerContext(
+                servicer_context, span)
+            try:
+                response = handler(request_or_iterator, servicer_context)
+            except:
+                e = sys.exc_info()[0]
+                span.set_tag('error', True)
+                span.log_kv({'event': 'error', 'error.object': e})
+                rpc_info.error = e
+                if self._span_decorator is not None:
+                    self._span_decorator(span, rpc_info)
+                raise
+            if self._log_payloads:
+                span.log_kv({'response': response})
+            _check_error_code(span, servicer_context, rpc_info)
+            rpc_info.response = response
+            if self._span_decorator is not None:
+                self._span_decorator(span, rpc_info)
+            return response

vendor/github.com/grpc-ecosystem/grpc-opentracing/python/grpc_opentracing/_utilities.py

@@ -0,0 +1,65 @@
+"""Internal utilities for gRPC OpenTracing."""
+
+import collections
+import grpc_opentracing
+
+
+class RpcInfo(grpc_opentracing.RpcInfo):
+
+    def __init__(self,
+                 full_method=None,
+                 metadata=None,
+                 timeout=None,
+                 request=None,
+                 response=None,
+                 error=None):
+        self.full_method = full_method
+        self.metadata = metadata
+        self.timeout = timeout
+        self.request = request
+        self.response = response
+        self.error = error
+
+
+def get_method_type(is_client_stream, is_server_stream):
+    if is_client_stream and is_server_stream:
+        return 'BIDI_STREAMING'
+    elif is_client_stream:
+        return 'CLIENT_STREAMING'
+    elif is_server_stream:
+        return 'SERVER_STREAMING'
+    else:
+        return 'UNARY'
+
+
+def get_deadline_millis(timeout):
+    if timeout is None:
+        return 'None'
+    return str(int(round(timeout * 1000)))
+
+
+class _RequestLoggingIterator(object):
+
+    def __init__(self, request_iterator, span):
+        self._request_iterator = request_iterator
+        self._span = span
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        request = next(self._request_iterator)
+        self._span.log_kv({'request': request})
+        return request
+
+    def __next__(self):
+        return self.next()
+
+
+def log_or_wrap_request_or_iterator(span, is_client_stream,
+                                    request_or_iterator):
+    if is_client_stream:
+        return _RequestLoggingIterator(request_or_iterator, span)
+    else:
+        span.log_kv({'request': request_or_iterator})
+        return request_or_iterator

vendor/github.com/grpc-ecosystem/grpc-opentracing/python/grpc_opentracing/grpcext/__init__.py

@@ -0,0 +1,185 @@
+import abc
+
+import six
+
+
+class UnaryClientInfo(six.with_metaclass(abc.ABCMeta)):
+    """Consists of various information about a unary RPC on the invocation-side.
+
+  Attributes:
+    full_method: A string of the full RPC method, i.e., /package.service/method.
+    timeout: The length of time in seconds to wait for the computation to
+      terminate or be cancelled, or None if this method should block until
+      the computation is terminated or is cancelled no matter how long that
+      takes.
+  """
+
+
+class StreamClientInfo(six.with_metaclass(abc.ABCMeta)):
+    """Consists of various information about a stream RPC on the invocation-side.
+
+  Attributes:
+    full_method: A string of the full RPC method, i.e., /package.service/method.
+    is_client_stream: Indicates whether the RPC is client-streaming.
+    is_server_stream: Indicates whether the RPC is server-streaming.
+    timeout: The length of time in seconds to wait for the computation to
+      terminate or be cancelled, or None if this method should block until
+      the computation is terminated or is cancelled no matter how long that
+      takes.
+  """
+
+
+class UnaryClientInterceptor(six.with_metaclass(abc.ABCMeta)):
+    """Affords intercepting unary-unary RPCs on the invocation-side."""
+
+    @abc.abstractmethod
+    def intercept_unary(self, request, metadata, client_info, invoker):
+        """Intercepts unary-unary RPCs on the invocation-side.
+
+    Args:
+      request: The request value for the RPC.
+      metadata: Optional :term:`metadata` to be transmitted to the
+        service-side of the RPC.
+      client_info: A UnaryClientInfo containing various information about
+        the RPC.
+      invoker: The handler to complete the RPC on the client. It is the
+        interceptor's responsibility to call it.
+
+    Returns:
+      The result from calling invoker(request, metadata).
+    """
+        raise NotImplementedError()
+
+
+class StreamClientInterceptor(six.with_metaclass(abc.ABCMeta)):
+    """Affords intercepting stream RPCs on the invocation-side."""
+
+    @abc.abstractmethod
+    def intercept_stream(self, request_or_iterator, metadata, client_info,
+                         invoker):
+        """Intercepts stream RPCs on the invocation-side.
+
+    Args:
+      request_or_iterator: The request value for the RPC if
+        `client_info.is_client_stream` is `false`; otherwise, an iterator of
+        request values.
+      metadata: Optional :term:`metadata` to be transmitted to the service-side
+        of the RPC.
+      client_info: A StreamClientInfo containing various information about
+        the RPC.
+      invoker:  The handler to complete the RPC on the client. It is the
+        interceptor's responsibility to call it.
+
+      Returns:
+        The result from calling invoker(metadata).
+    """
+        raise NotImplementedError()
+
+
+def intercept_channel(channel, *interceptors):
+    """Creates an intercepted channel.
+
+  Args:
+    channel: A Channel.
+    interceptors: Zero or more UnaryClientInterceptors or
+      StreamClientInterceptors
+
+  Returns:
+    A Channel.
+
+  Raises:
+    TypeError: If an interceptor derives from neither UnaryClientInterceptor
+      nor StreamClientInterceptor.
+  """
+    from grpc_opentracing.grpcext import _interceptor
+    return _interceptor.intercept_channel(channel, *interceptors)
+
+
+class UnaryServerInfo(six.with_metaclass(abc.ABCMeta)):
+    """Consists of various information about a unary RPC on the service-side.
+
+  Attributes:
+    full_method: A string of the full RPC method, i.e., /package.service/method.
+  """
+
+
+class StreamServerInfo(six.with_metaclass(abc.ABCMeta)):
+    """Consists of various information about a stream RPC on the service-side.
+
+  Attributes:
+    full_method: A string of the full RPC method, i.e., /package.service/method.
+    is_client_stream: Indicates whether the RPC is client-streaming.
+    is_server_stream: Indicates whether the RPC is server-streaming.
+  """
+
+
+class UnaryServerInterceptor(six.with_metaclass(abc.ABCMeta)):
+    """Affords intercepting unary-unary RPCs on the service-side."""
+
+    @abc.abstractmethod
+    def intercept_unary(self, request, servicer_context, server_info, handler):
+        """Intercepts unary-unary RPCs on the service-side.
+
+    Args:
+      request: The request value for the RPC.
+      servicer_context: A ServicerContext.
+      server_info: A UnaryServerInfo containing various information about
+        the RPC.
+      handler:  The handler to complete the RPC on the server. It is the
+        interceptor's responsibility to call it.
+
+    Returns:
+      The result from calling handler(request, servicer_context).
+    """
+        raise NotImplementedError()
+
+
+class StreamServerInterceptor(six.with_metaclass(abc.ABCMeta)):
+    """Affords intercepting stream RPCs on the service-side."""
+
+    @abc.abstractmethod
+    def intercept_stream(self, request_or_iterator, servicer_context,
+                         server_info, handler):
+        """Intercepts stream RPCs on the service-side.
+
+    Args:
+      request_or_iterator: The request value for the RPC if
+        `server_info.is_client_stream` is `False`; otherwise, an iterator of
+        request values.
+      servicer_context: A ServicerContext.
+      server_info: A StreamServerInfo containing various information about
+        the RPC.
+      handler:  The handler to complete the RPC on the server. It is the
+        interceptor's responsibility to call it.
+
+      Returns:
+        The result from calling handler(servicer_context).
+    """
+        raise NotImplementedError()
+
+
+def intercept_server(server, *interceptors):
+    """Creates an intercepted server.
+
+  Args:
+    server: A Server.
+    interceptors: Zero or more UnaryServerInterceptors or
+      StreamServerInterceptors
+
+  Returns:
+    A Server.
+
+  Raises:
+    TypeError: If an interceptor derives from neither UnaryServerInterceptor
+      nor StreamServerInterceptor.
+  """
+    from grpc_opentracing.grpcext import _interceptor
+    return _interceptor.intercept_server(server, *interceptors)
+
+
+###################################  __all__  #################################
+
+__all__ = ('UnaryClientInterceptor', 'StreamClientInfo',
+           'StreamClientInterceptor', 'UnaryServerInfo', 'StreamServerInfo',
+           'UnaryServerInterceptor', 'StreamServerInterceptor',
+           'intercept_channel', 'intercept_server',)

vendor/github.com/grpc-ecosystem/grpc-opentracing/python/grpc_opentracing/grpcext/_interceptor.py

@@ -0,0 +1,373 @@
+"""Implementation of gRPC Python interceptors."""
+
+import collections
+
+import grpc
+from grpc_opentracing import grpcext
+
+
+class _UnaryClientInfo(
+        collections.namedtuple('_UnaryClientInfo',
+                               ('full_method', 'timeout',))):
+    pass
+
+
+class _StreamClientInfo(
+        collections.namedtuple('_StreamClientInfo', (
+            'full_method', 'is_client_stream', 'is_server_stream', 'timeout'))):
+    pass
+
+
+class _InterceptorUnaryUnaryMultiCallable(grpc.UnaryUnaryMultiCallable):
+
+    def __init__(self, method, base_callable, interceptor):
+        self._method = method
+        self._base_callable = base_callable
+        self._interceptor = interceptor
+
+    def __call__(self, request, timeout=None, metadata=None, credentials=None):
+
+        def invoker(request, metadata):
+            return self._base_callable(request, timeout, metadata, credentials)
+
+        client_info = _UnaryClientInfo(self._method, timeout)
+        return self._interceptor.intercept_unary(request, metadata, client_info,
+                                                 invoker)
+
+    def with_call(self, request, timeout=None, metadata=None, credentials=None):
+
+        def invoker(request, metadata):
+            return self._base_callable.with_call(request, timeout, metadata,
+                                                 credentials)
+
+        client_info = _UnaryClientInfo(self._method, timeout)
+        return self._interceptor.intercept_unary(request, metadata, client_info,
+                                                 invoker)
+
+    def future(self, request, timeout=None, metadata=None, credentials=None):
+
+        def invoker(request, metadata):
+            return self._base_callable.future(request, timeout, metadata,
+                                              credentials)
+
+        client_info = _UnaryClientInfo(self._method, timeout)
+        return self._interceptor.intercept_unary(request, metadata, client_info,
+                                                 invoker)
+
+
+class _InterceptorUnaryStreamMultiCallable(grpc.UnaryStreamMultiCallable):
+
+    def __init__(self, method, base_callable, interceptor):
+        self._method = method
+        self._base_callable = base_callable
+        self._interceptor = interceptor
+
+    def __call__(self, request, timeout=None, metadata=None, credentials=None):
+
+        def invoker(request, metadata):
+            return self._base_callable(request, timeout, metadata, credentials)
+
+        client_info = _StreamClientInfo(self._method, False, True, timeout)
+        return self._interceptor.intercept_stream(request, metadata,
+                                                  client_info, invoker)
+
+
+class _InterceptorStreamUnaryMultiCallable(grpc.StreamUnaryMultiCallable):
+
+    def __init__(self, method, base_callable, interceptor):
+        self._method = method
+        self._base_callable = base_callable
+        self._interceptor = interceptor
+
+    def __call__(self,
+                 request_iterator,
+                 timeout=None,
+                 metadata=None,
+                 credentials=None):
+
+        def invoker(request_iterator, metadata):
+            return self._base_callable(request_iterator, timeout, metadata,
+                                       credentials)
+
+        client_info = _StreamClientInfo(self._method, True, False, timeout)
+        return self._interceptor.intercept_stream(request_iterator, metadata,
+                                                  client_info, invoker)
+
+    def with_call(self,
+                  request_iterator,
+                  timeout=None,
+                  metadata=None,
+                  credentials=None):
+
+        def invoker(request_iterator, metadata):
+            return self._base_callable.with_call(request_iterator, timeout,
+                                                 metadata, credentials)
+
+        client_info = _StreamClientInfo(self._method, True, False, timeout)
+        return self._interceptor.intercept_stream(request_iterator, metadata,
+                                                  client_info, invoker)
+
+    def future(self,
+               request_iterator,
+               timeout=None,
+               metadata=None,
+               credentials=None):
+
+        def invoker(request_iterator, metadata):
+            return self._base_callable.future(request_iterator, timeout,
+                                              metadata, credentials)
+
+        client_info = _StreamClientInfo(self._method, True, False, timeout)
+        return self._interceptor.intercept_stream(request_iterator, metadata,
+                                                  client_info, invoker)
+
+
+class _InterceptorStreamStreamMultiCallable(grpc.StreamStreamMultiCallable):
+
+    def __init__(self, method, base_callable, interceptor):
+        self._method = method
+        self._base_callable = base_callable
+        self._interceptor = interceptor
+
+    def __call__(self,
+                 request_iterator,
+                 timeout=None,
+                 metadata=None,
+                 credentials=None):
+
+        def invoker(request_iterator, metadata):
+            return self._base_callable(request_iterator, timeout, metadata,
+                                       credentials)
+
+        client_info = _StreamClientInfo(self._method, True, True, timeout)
+        return self._interceptor.intercept_stream(request_iterator, metadata,
+                                                  client_info, invoker)
+
+
+class _InterceptorChannel(grpc.Channel):
+
+    def __init__(self, channel, interceptor):
+        self._channel = channel
+        self._interceptor = interceptor
+
+    def subscribe(self, *args, **kwargs):
+        self._channel.subscribe(*args, **kwargs)
+
+    def unsubscribe(self, *args, **kwargs):
+        self._channel.unsubscribe(*args, **kwargs)
+
+    def unary_unary(self,
+                    method,
+                    request_serializer=None,
+                    response_deserializer=None):
+        base_callable = self._channel.unary_unary(method, request_serializer,
+                                                  response_deserializer)
+        if isinstance(self._interceptor, grpcext.UnaryClientInterceptor):
+            return _InterceptorUnaryUnaryMultiCallable(method, base_callable,
+                                                       self._interceptor)
+        else:
+            return base_callable
+
+    def unary_stream(self,
+                     method,
+                     request_serializer=None,
+                     response_deserializer=None):
+        base_callable = self._channel.unary_stream(method, request_serializer,
+                                                   response_deserializer)
+        if isinstance(self._interceptor, grpcext.StreamClientInterceptor):
+            return _InterceptorUnaryStreamMultiCallable(method, base_callable,
+                                                        self._interceptor)
+        else:
+            return base_callable
+
+    def stream_unary(self,
+                     method,
+                     request_serializer=None,
+                     response_deserializer=None):
+        base_callable = self._channel.stream_unary(method, request_serializer,
+                                                   response_deserializer)
+        if isinstance(self._interceptor, grpcext.StreamClientInterceptor):
+            return _InterceptorStreamUnaryMultiCallable(method, base_callable,
+                                                        self._interceptor)
+        else:
+            return base_callable
+
+    def stream_stream(self,
+                      method,
+                      request_serializer=None,
+                      response_deserializer=None):
+        base_callable = self._channel.stream_stream(method, request_serializer,
+                                                    response_deserializer)
+        if isinstance(self._interceptor, grpcext.StreamClientInterceptor):
+            return _InterceptorStreamStreamMultiCallable(method, base_callable,
+                                                         self._interceptor)
+        else:
+            return base_callable
+
+
+def intercept_channel(channel, *interceptors):
+    result = channel
+    for interceptor in interceptors:
+        if not isinstance(interceptor, grpcext.UnaryClientInterceptor) and \
+           not isinstance(interceptor, grpcext.StreamClientInterceptor):
+            raise TypeError('interceptor must be either a '
+                            'grpcext.UnaryClientInterceptor or a '
+                            'grpcext.StreamClientInterceptor')
+        result = _InterceptorChannel(result, interceptor)
+    return result
+
+
+class _UnaryServerInfo(
+        collections.namedtuple('_UnaryServerInfo', ('full_method',))):
+    pass
+
+
+class _StreamServerInfo(
+        collections.namedtuple('_StreamServerInfo', (
+            'full_method', 'is_client_stream', 'is_server_stream'))):
+    pass
+
+
+class _InterceptorRpcMethodHandler(grpc.RpcMethodHandler):
+
+    def __init__(self, rpc_method_handler, method, interceptor):
+        self._rpc_method_handler = rpc_method_handler
+        self._method = method
+        self._interceptor = interceptor
+
+    @property
+    def request_streaming(self):
+        return self._rpc_method_handler.request_streaming
+
+    @property
+    def response_streaming(self):
+        return self._rpc_method_handler.response_streaming
+
+    @property
+    def request_deserializer(self):
+        return self._rpc_method_handler.request_deserializer
+
+    @property
+    def response_serializer(self):
+        return self._rpc_method_handler.response_serializer
+
+    @property
+    def unary_unary(self):
+        if not isinstance(self._interceptor, grpcext.UnaryServerInterceptor):
+            return self._rpc_method_handler.unary_unary
+
+        def adaptation(request, servicer_context):
+
+            def handler(request, servicer_context):
+                return self._rpc_method_handler.unary_unary(request,
+                                                            servicer_context)
+
+            return self._interceptor.intercept_unary(
+                request, servicer_context,
+                _UnaryServerInfo(self._method), handler)
+
+        return adaptation
+
+    @property
+    def unary_stream(self):
+        if not isinstance(self._interceptor, grpcext.StreamServerInterceptor):
+            return self._rpc_method_handler.unary_stream
+
+        def adaptation(request, servicer_context):
+
+            def handler(request, servicer_context):
+                return self._rpc_method_handler.unary_stream(request,
+                                                             servicer_context)
+
+            return self._interceptor.intercept_stream(
+                request, servicer_context,
+                _StreamServerInfo(self._method, False, True), handler)
+
+        return adaptation
+
+    @property
+    def stream_unary(self):
+        if not isinstance(self._interceptor, grpcext.StreamServerInterceptor):
+            return self._rpc_method_handler.stream_unary
+
+        def adaptation(request_iterator, servicer_context):
+
+            def handler(request_iterator, servicer_context):
+                return self._rpc_method_handler.stream_unary(request_iterator,
+                                                             servicer_context)
+
+            return self._interceptor.intercept_stream(
+                request_iterator, servicer_context,
+                _StreamServerInfo(self._method, True, False), handler)
+
+        return adaptation
+
+    @property
+    def stream_stream(self):
+        if not isinstance(self._interceptor, grpcext.StreamServerInterceptor):
+            return self._rpc_method_handler.stream_stream
+
+        def adaptation(request_iterator, servicer_context):
+
+            def handler(request_iterator, servicer_context):
+                return self._rpc_method_handler.stream_stream(request_iterator,
+                                                              servicer_context)
+
+            return self._interceptor.intercept_stream(
+                request_iterator, servicer_context,
+                _StreamServerInfo(self._method, True, True), handler)
+
+        return adaptation
+
+
+class _InterceptorGenericRpcHandler(grpc.GenericRpcHandler):
+
+    def __init__(self, generic_rpc_handler, interceptor):
+        self.generic_rpc_handler = generic_rpc_handler
+        self._interceptor = interceptor
+
+    def service(self, handler_call_details):
+        result = self.generic_rpc_handler.service(handler_call_details)
+        if result:
+            result = _InterceptorRpcMethodHandler(
+                result, handler_call_details.method, self._interceptor)
+        return result
+
+
+class _InterceptorServer(grpc.Server):
+
+    def __init__(self, server, interceptor):
+        self._server = server
+        self._interceptor = interceptor
+
+    def add_generic_rpc_handlers(self, generic_rpc_handlers):
+        generic_rpc_handlers = [
+            _InterceptorGenericRpcHandler(generic_rpc_handler,
+                                          self._interceptor)
+            for generic_rpc_handler in generic_rpc_handlers
+        ]
+        return self._server.add_generic_rpc_handlers(generic_rpc_handlers)
+
+    def add_insecure_port(self, *args, **kwargs):
+        return self._server.add_insecure_port(*args, **kwargs)
+
+    def add_secure_port(self, *args, **kwargs):
+        return self._server.add_secure_port(*args, **kwargs)
+
+    def start(self, *args, **kwargs):
+        return self._server.start(*args, **kwargs)
+
+    def stop(self, *args, **kwargs):
+        return self._server.stop(*args, **kwargs)
+
+
+def intercept_server(server, *interceptors):
+    result = server
+    for interceptor in interceptors:
+        if not isinstance(interceptor, grpcext.UnaryServerInterceptor) and \
+           not isinstance(interceptor, grpcext.StreamServerInterceptor):
+            raise TypeError('interceptor must be either a '
+                            'grpcext.UnaryServerInterceptor or a '
+                            'grpcext.StreamServerInterceptor')
+        result = _InterceptorServer(result, interceptor)
+    return result