TUN-528: Move cloudflared into a separate repo

vendor/github.com/grpc-ecosystem/grpc-opentracing/python/tests/_service.py

@@ -0,0 +1,192 @@
+"""Creates a simple service on top of gRPC for testing."""
+
+from builtins import input, range
+
+import grpc
+from grpc.framework.foundation import logging_pool
+from grpc_opentracing import grpcext
+
+_SERIALIZE_REQUEST = lambda bytestring: bytestring
+_DESERIALIZE_REQUEST = lambda bytestring: bytestring
+_SERIALIZE_RESPONSE = lambda bytestring: bytestring
+_DESERIALIZE_RESPONSE = lambda bytestring: bytestring
+
+_UNARY_UNARY = '/test/UnaryUnary'
+_UNARY_STREAM = '/test/UnaryStream'
+_STREAM_UNARY = '/test/StreamUnary'
+_STREAM_STREAM = '/test/StreamStream'
+
+_STREAM_LENGTH = 5
+
+
+class _MethodHandler(grpc.RpcMethodHandler):
+
+    def __init__(self,
+                 request_streaming=False,
+                 response_streaming=False,
+                 unary_unary=None,
+                 unary_stream=None,
+                 stream_unary=None,
+                 stream_stream=None):
+        self.request_streaming = request_streaming
+        self.response_streaming = response_streaming
+        self.request_deserializer = _DESERIALIZE_REQUEST
+        self.response_serializer = _SERIALIZE_RESPONSE
+        self.unary_unary = unary_unary
+        self.unary_stream = unary_stream
+        self.stream_unary = stream_unary
+        self.stream_stream = stream_stream
+
+
+class Handler(object):
+
+    def __init__(self):
+        self.invocation_metadata = None
+        self.trailing_metadata = None
+
+    def handle_unary_unary(self, request, servicer_context):
+        if servicer_context is not None:
+            self.invocation_metadata = servicer_context.invocation_metadata()
+            if self.trailing_metadata is not None:
+                servicer_context.set_trailing_metadata(self.trailing_metadata)
+        return request
+
+    def handle_unary_stream(self, request, servicer_context):
+        if servicer_context is not None:
+            self.invocation_metadata = servicer_context.invocation_metadata()
+            if self.trailing_metadata is not None:
+                servicer_context.set_trailing_metadata(self.trailing_metadata)
+        for _ in range(_STREAM_LENGTH):
+            yield request
+
+    def handle_stream_unary(self, request_iterator, servicer_context):
+        if servicer_context is not None:
+            self.invocation_metadata = servicer_context.invocation_metadata()
+            if self.trailing_metadata is not None:
+                servicer_context.set_trailing_metadata(self.trailing_metadata)
+        return b''.join(list(request_iterator))
+
+    def handle_stream_stream(self, request_iterator, servicer_context):
+        if servicer_context is not None:
+            self.invocation_metadata = servicer_context.invocation_metadata()
+            if self.trailing_metadata is not None:
+                servicer_context.set_trailing_metadata(self.trailing_metadata)
+        for request in request_iterator:
+            yield request
+
+
+def _set_error_code(servicer_context):
+    servicer_context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
+    servicer_context.set_details('ErroringHandler')
+
+
+class ErroringHandler(Handler):
+
+    def __init__(self):
+        super(ErroringHandler, self).__init__()
+
+    def handle_unary_unary(self, request, servicer_context):
+        _set_error_code(servicer_context)
+        return super(ErroringHandler, self).handle_unary_unary(request,
+                                                               servicer_context)
+
+    def handle_unary_stream(self, request, servicer_context):
+        _set_error_code(servicer_context)
+        return super(ErroringHandler, self).handle_unary_stream(
+            request, servicer_context)
+
+    def handle_stream_unary(self, request_iterator, servicer_context):
+        _set_error_code(servicer_context)
+        return super(ErroringHandler, self).handle_stream_unary(
+            request_iterator, servicer_context)
+
+    def handle_stream_stream(self, request_iterator, servicer_context):
+        _set_error_code(servicer_context)
+        return super(ErroringHandler, self).handle_stream_stream(
+            request_iterator, servicer_context)
+
+
+class ExceptionErroringHandler(Handler):
+
+    def __init__(self):
+        super(ExceptionErroringHandler, self).__init__()
+
+    def handle_unary_unary(self, request, servicer_context):
+        raise IndexError()
+
+    def handle_unary_stream(self, request, servicer_context):
+        raise IndexError()
+
+    def handle_stream_unary(self, request_iterator, servicer_context):
+        raise IndexError()
+
+    def handle_stream_stream(self, request_iterator, servicer_context):
+        raise IndexError()
+
+
+class _GenericHandler(grpc.GenericRpcHandler):
+
+    def __init__(self, handler):
+        self._handler = handler
+
+    def service(self, handler_call_details):
+        method = handler_call_details.method
+        if method == _UNARY_UNARY:
+            return _MethodHandler(unary_unary=self._handler.handle_unary_unary)
+        elif method == _UNARY_STREAM:
+            return _MethodHandler(
+                response_streaming=True,
+                unary_stream=self._handler.handle_unary_stream)
+        elif method == _STREAM_UNARY:
+            return _MethodHandler(
+                request_streaming=True,
+                stream_unary=self._handler.handle_stream_unary)
+        elif method == _STREAM_STREAM:
+            return _MethodHandler(
+                request_streaming=True,
+                response_streaming=True,
+                stream_stream=self._handler.handle_stream_stream)
+        else:
+            return None
+
+
+class Service(object):
+
+    def __init__(self,
+                 client_interceptors,
+                 server_interceptors,
+                 handler=Handler()):
+        self.handler = handler
+        self._server_pool = logging_pool.pool(2)
+        self._server = grpcext.intercept_server(
+            grpc.server(self._server_pool), *server_interceptors)
+        port = self._server.add_insecure_port('[::]:0')
+        self._server.add_generic_rpc_handlers((_GenericHandler(self.handler),))
+        self._server.start()
+        self.channel = grpcext.intercept_channel(
+            grpc.insecure_channel('localhost:%d' % port), *client_interceptors)
+
+    @property
+    def unary_unary_multi_callable(self):
+        return self.channel.unary_unary(_UNARY_UNARY)
+
+    @property
+    def unary_stream_multi_callable(self):
+        return self.channel.unary_stream(
+            _UNARY_STREAM,
+            request_serializer=_SERIALIZE_REQUEST,
+            response_deserializer=_DESERIALIZE_RESPONSE)
+
+    @property
+    def stream_unary_multi_callable(self):
+        return self.channel.stream_unary(
+            _STREAM_UNARY,
+            request_serializer=_SERIALIZE_REQUEST,
+            response_deserializer=_DESERIALIZE_RESPONSE)
+
+    @property
+    def stream_stream_multi_callable(self):
+        return self.channel.stream_stream(
+            _STREAM_STREAM,
+            request_serializer=_SERIALIZE_REQUEST,
+            response_deserializer=_DESERIALIZE_RESPONSE)

vendor/github.com/grpc-ecosystem/grpc-opentracing/python/tests/_tracer.py

@@ -0,0 +1,83 @@
+from collections import defaultdict
+import enum
+
+import opentracing
+
+
+@enum.unique
+class SpanRelationship(enum.Enum):
+    NONE = 0
+    FOLLOWS_FROM = 1
+    CHILD_OF = 2
+
+
+class _SpanContext(opentracing.SpanContext):
+
+    def __init__(self, identity):
+        self.identity = identity
+
+
+class _Span(opentracing.Span):
+
+    def __init__(self, tracer, identity, tags=None):
+        super(_Span, self).__init__(tracer, _SpanContext(identity))
+        self._identity = identity
+        if tags is None:
+            tags = {}
+        self._tags = tags
+
+    def set_tag(self, key, value):
+        self._tags[key] = value
+
+    def get_tag(self, key):
+        return self._tags.get(key, None)
+
+
+class Tracer(opentracing.Tracer):
+
+    def __init__(self):
+        super(Tracer, self).__init__()
+        self._counter = 0
+        self._spans = {}
+        self._relationships = defaultdict(lambda: None)
+
+    def start_span(self,
+                   operation_name=None,
+                   child_of=None,
+                   references=None,
+                   tags=None,
+                   start_time=None):
+        identity = self._counter
+        self._counter += 1
+        if child_of is not None:
+            self._relationships[(child_of.identity,
+                                 identity)] = opentracing.ReferenceType.CHILD_OF
+        if references is not None:
+            assert child_of is None and len(
+                references) == 1, 'Only a single reference is supported'
+            reference_type, span_context = references[0]
+            self._relationships[(span_context.identity,
+                                 identity)] = reference_type
+        span = _Span(self, identity, tags)
+        self._spans[identity] = span
+        return span
+
+    def inject(self, span_context, format, carrier):
+        if format != opentracing.Format.HTTP_HEADERS and isinstance(carrier,
+                                                                    dict):
+            raise opentracing.UnsupportedFormatException(format)
+        carrier['span-identity'] = str(span_context.identity)
+
+    def extract(self, format, carrier):
+        if format != opentracing.Format.HTTP_HEADERS and isinstance(carrier,
+                                                                    dict):
+            raise opentracing.UnsupportedFormatException(format)
+        if 'span-identity' not in carrier:
+            raise opentracing.SpanContextCorruptedException
+        return _SpanContext(int(carrier['span-identity']))
+
+    def get_relationship(self, identity1, identity2):
+        return self._relationships[(identity1, identity2)]
+
+    def get_span(self, identity):
+        return self._spans.get(identity, None)

vendor/github.com/grpc-ecosystem/grpc-opentracing/python/tests/test_interceptor.py

@@ -0,0 +1,168 @@
+import unittest
+
+import grpc
+from grpc_opentracing import grpcext
+
+from _service import Service
+
+
+class ClientInterceptor(grpcext.UnaryClientInterceptor,
+                        grpcext.StreamClientInterceptor):
+
+    def __init__(self):
+        self.intercepted = False
+
+    def intercept_unary(self, request, metadata, client_info, invoker):
+        self.intercepted = True
+        return invoker(request, metadata)
+
+    def intercept_stream(self, request_or_iterator, metadata, client_info,
+                         invoker):
+        self.intercepted = True
+        return invoker(request_or_iterator, metadata)
+
+
+class ServerInterceptor(grpcext.UnaryServerInterceptor,
+                        grpcext.StreamServerInterceptor):
+
+    def __init__(self):
+        self.intercepted = False
+
+    def intercept_unary(self, request, servicer_context, server_info, handler):
+        self.intercepted = True
+        return handler(request, servicer_context)
+
+    def intercept_stream(self, request_or_iterator, servicer_context,
+                         server_info, handler):
+        self.intercepted = True
+        return handler(request_or_iterator, servicer_context)
+
+
+class InterceptorTest(unittest.TestCase):
+    """Test that RPC calls are intercepted."""
+
+    def setUp(self):
+        self._client_interceptor = ClientInterceptor()
+        self._server_interceptor = ServerInterceptor()
+        self._service = Service([self._client_interceptor],
+                                [self._server_interceptor])
+
+    def testUnaryUnaryInterception(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_unary(request,
+                                                                     None)
+        response = multi_callable(request)
+
+        self.assertEqual(response, expected_response)
+        self.assertTrue(self._client_interceptor.intercepted)
+        self.assertTrue(self._server_interceptor.intercepted)
+
+    def testUnaryUnaryInterceptionWithCall(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_unary(request,
+                                                                     None)
+        response, call = multi_callable.with_call(request)
+
+        self.assertEqual(response, expected_response)
+        self.assertIs(grpc.StatusCode.OK, call.code())
+        self.assertTrue(self._client_interceptor.intercepted)
+        self.assertTrue(self._server_interceptor.intercepted)
+
+    def testUnaryUnaryInterceptionFuture(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_unary(request,
+                                                                     None)
+        response = multi_callable.future(request).result()
+
+        self.assertEqual(response, expected_response)
+        self.assertTrue(self._client_interceptor.intercepted)
+        self.assertTrue(self._server_interceptor.intercepted)
+
+    def testUnaryStreamInterception(self):
+        multi_callable = self._service.unary_stream_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_stream(request,
+                                                                      None)
+        response = multi_callable(request)
+
+        self.assertEqual(list(response), list(expected_response))
+        self.assertTrue(self._client_interceptor.intercepted)
+        self.assertTrue(self._server_interceptor.intercepted)
+
+    def testStreamUnaryInterception(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_unary(
+            iter(requests), None)
+        response = multi_callable(iter(requests))
+
+        self.assertEqual(response, expected_response)
+        self.assertTrue(self._client_interceptor.intercepted)
+        self.assertTrue(self._server_interceptor.intercepted)
+
+    def testStreamUnaryInterceptionWithCall(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_unary(
+            iter(requests), None)
+        response, call = multi_callable.with_call(iter(requests))
+
+        self.assertEqual(response, expected_response)
+        self.assertIs(grpc.StatusCode.OK, call.code())
+        self.assertTrue(self._client_interceptor.intercepted)
+        self.assertTrue(self._server_interceptor.intercepted)
+
+    def testStreamUnaryInterceptionFuture(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_unary(
+            iter(requests), None)
+        response = multi_callable.future(iter(requests)).result()
+
+        self.assertEqual(response, expected_response)
+        self.assertTrue(self._client_interceptor.intercepted)
+        self.assertTrue(self._server_interceptor.intercepted)
+
+    def testStreamStreamInterception(self):
+        multi_callable = self._service.stream_stream_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_stream(
+            iter(requests), None)
+        response = multi_callable(iter(requests))
+
+        self.assertEqual(list(response), list(expected_response))
+        self.assertTrue(self._client_interceptor.intercepted)
+        self.assertTrue(self._server_interceptor.intercepted)
+
+
+class MultiInterceptorTest(unittest.TestCase):
+    """Test that you can chain multiple interceptors together."""
+
+    def setUp(self):
+        self._client_interceptors = [ClientInterceptor(), ClientInterceptor()]
+        self._server_interceptors = [ServerInterceptor(), ServerInterceptor()]
+        self._service = Service(self._client_interceptors,
+                                self._server_interceptors)
+
+    def _clear(self):
+        for client_interceptor in self._client_interceptors:
+            client_interceptor.intercepted = False
+
+        for server_interceptor in self._server_interceptors:
+            server_interceptor.intercepted = False
+
+    def testUnaryUnaryMultiInterception(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_unary(request,
+                                                                     None)
+        response = multi_callable(request)
+
+        self.assertEqual(response, expected_response)
+        for client_interceptor in self._client_interceptors:
+            self.assertTrue(client_interceptor.intercepted)
+        for server_interceptor in self._server_interceptors:
+            self.assertTrue(server_interceptor.intercepted)

vendor/github.com/grpc-ecosystem/grpc-opentracing/python/tests/test_opentracing.py

@@ -0,0 +1,611 @@
+import unittest
+
+import grpc
+
+from _service import Service, ErroringHandler, ExceptionErroringHandler
+from _tracer import Tracer, SpanRelationship
+from grpc_opentracing import open_tracing_client_interceptor, open_tracing_server_interceptor
+import opentracing
+
+
+class OpenTracingTest(unittest.TestCase):
+    """Test that tracers create the correct spans when RPC calls are invoked."""
+
+    def setUp(self):
+        self._tracer = Tracer()
+        self._service = Service([open_tracing_client_interceptor(self._tracer)],
+                                [open_tracing_server_interceptor(self._tracer)])
+
+    def testUnaryUnaryOpenTracing(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_unary(request,
+                                                                     None)
+        response = multi_callable(request)
+
+        self.assertEqual(response, expected_response)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertEqual(span1.get_tag('span.kind'), 'server')
+
+        self.assertEqual(
+            self._tracer.get_relationship(0, 1),
+            opentracing.ReferenceType.CHILD_OF)
+
+    def testUnaryUnaryOpenTracingFuture(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_unary(request,
+                                                                     None)
+        future = multi_callable.future(request)
+        response = future.result()
+
+        self.assertEqual(response, expected_response)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertEqual(span1.get_tag('span.kind'), 'server')
+
+        self.assertEqual(
+            self._tracer.get_relationship(0, 1),
+            opentracing.ReferenceType.CHILD_OF)
+
+    def testUnaryUnaryOpenTracingWithCall(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_unary(request,
+                                                                     None)
+        response, call = multi_callable.with_call(request)
+
+        self.assertEqual(response, expected_response)
+        self.assertIs(grpc.StatusCode.OK, call.code())
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertEqual(span1.get_tag('span.kind'), 'server')
+
+        self.assertEqual(
+            self._tracer.get_relationship(0, 1),
+            opentracing.ReferenceType.CHILD_OF)
+
+    def testUnaryStreamOpenTracing(self):
+        multi_callable = self._service.unary_stream_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_stream(request,
+                                                                      None)
+        response = multi_callable(request)
+
+        self.assertEqual(list(response), list(expected_response))
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertEqual(span1.get_tag('span.kind'), 'server')
+
+        self.assertEqual(
+            self._tracer.get_relationship(0, 1),
+            opentracing.ReferenceType.CHILD_OF)
+
+    def testStreamUnaryOpenTracing(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_unary(
+            iter(requests), None)
+        response = multi_callable(iter(requests))
+
+        self.assertEqual(response, expected_response)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertEqual(span1.get_tag('span.kind'), 'server')
+
+        self.assertEqual(
+            self._tracer.get_relationship(0, 1),
+            opentracing.ReferenceType.CHILD_OF)
+
+    def testStreamUnaryOpenTracingWithCall(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_unary(
+            iter(requests), None)
+        response, call = multi_callable.with_call(iter(requests))
+
+        self.assertEqual(response, expected_response)
+        self.assertIs(grpc.StatusCode.OK, call.code())
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertEqual(span1.get_tag('span.kind'), 'server')
+
+        self.assertEqual(
+            self._tracer.get_relationship(0, 1),
+            opentracing.ReferenceType.CHILD_OF)
+
+    def testStreamUnaryOpenTracingFuture(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_unary(
+            iter(requests), None)
+        result = multi_callable.future(iter(requests))
+        response = result.result()
+
+        self.assertEqual(response, expected_response)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertEqual(span1.get_tag('span.kind'), 'server')
+
+        self.assertEqual(
+            self._tracer.get_relationship(0, 1),
+            opentracing.ReferenceType.CHILD_OF)
+
+    def testStreamStreamOpenTracing(self):
+        multi_callable = self._service.stream_stream_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_stream(
+            iter(requests), None)
+        response = multi_callable(iter(requests))
+
+        self.assertEqual(list(response), list(expected_response))
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertEqual(span1.get_tag('span.kind'), 'server')
+
+        self.assertEqual(
+            self._tracer.get_relationship(0, 1),
+            opentracing.ReferenceType.CHILD_OF)
+
+
+class OpenTracingInteroperabilityClientTest(unittest.TestCase):
+    """Test that a traced client can interoperate with a non-trace server."""
+
+    def setUp(self):
+        self._tracer = Tracer()
+        self._service = Service([open_tracing_client_interceptor(self._tracer)],
+                                [])
+
+    def testUnaryUnaryOpenTracing(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_unary(request,
+                                                                     None)
+        response = multi_callable(request)
+
+        self.assertEqual(response, expected_response)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNone(span1)
+
+    def testUnaryUnaryOpenTracingWithCall(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_unary(request,
+                                                                     None)
+        response, call = multi_callable.with_call(request)
+
+        self.assertEqual(response, expected_response)
+        self.assertIs(grpc.StatusCode.OK, call.code())
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNone(span1)
+
+    def testUnaryStreamOpenTracing(self):
+        multi_callable = self._service.unary_stream_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_stream(request,
+                                                                      None)
+        response = multi_callable(request)
+
+        self.assertEqual(list(response), list(expected_response))
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNone(span1)
+
+    def testStreamUnaryOpenTracing(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_unary(
+            iter(requests), None)
+        response = multi_callable(iter(requests))
+
+        self.assertEqual(response, expected_response)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNone(span1)
+
+    def testStreamUnaryOpenTracingWithCall(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_unary(
+            iter(requests), None)
+        response, call = multi_callable.with_call(iter(requests))
+
+        self.assertEqual(response, expected_response)
+        self.assertIs(grpc.StatusCode.OK, call.code())
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNone(span1)
+
+    def testStreamStreamOpenTracing(self):
+        multi_callable = self._service.stream_stream_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_stream(
+            iter(requests), None)
+        response = multi_callable(iter(requests))
+
+        self.assertEqual(list(response), list(expected_response))
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'client')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNone(span1)
+
+
+class OpenTracingMetadataTest(unittest.TestCase):
+    """Test that open-tracing doesn't interfere with passing metadata through the
+    RPC.
+  """
+
+    def setUp(self):
+        self._tracer = Tracer()
+        self._service = Service([open_tracing_client_interceptor(self._tracer)],
+                                [open_tracing_server_interceptor(self._tracer)])
+
+    def testInvocationMetadata(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        multi_callable(request, None, (('abc', '123'),))
+        self.assertIn(('abc', '123'), self._service.handler.invocation_metadata)
+
+    def testTrailingMetadata(self):
+        self._service.handler.trailing_metadata = (('abc', '123'),)
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        future = multi_callable.future(request, None, (('abc', '123'),))
+        self.assertIn(('abc', '123'), future.trailing_metadata())
+
+
+class OpenTracingInteroperabilityServerTest(unittest.TestCase):
+    """Test that a traced server can interoperate with a non-trace client."""
+
+    def setUp(self):
+        self._tracer = Tracer()
+        self._service = Service([],
+                                [open_tracing_server_interceptor(self._tracer)])
+
+    def testUnaryUnaryOpenTracing(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_unary(request,
+                                                                     None)
+        response = multi_callable(request)
+
+        self.assertEqual(response, expected_response)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'server')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNone(span1)
+
+    def testUnaryUnaryOpenTracingWithCall(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_unary(request,
+                                                                     None)
+        response, call = multi_callable.with_call(request)
+
+        self.assertEqual(response, expected_response)
+        self.assertIs(grpc.StatusCode.OK, call.code())
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'server')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNone(span1)
+
+    def testUnaryStreamOpenTracing(self):
+        multi_callable = self._service.unary_stream_multi_callable
+        request = b'\x01'
+        expected_response = self._service.handler.handle_unary_stream(request,
+                                                                      None)
+        response = multi_callable(request)
+
+        self.assertEqual(list(response), list(expected_response))
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'server')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNone(span1)
+
+    def testStreamUnaryOpenTracing(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_unary(
+            iter(requests), None)
+        response = multi_callable(iter(requests))
+
+        self.assertEqual(response, expected_response)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'server')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNone(span1)
+
+    def testStreamUnaryOpenTracingWithCall(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_unary(
+            iter(requests), None)
+        response, call = multi_callable.with_call(iter(requests))
+
+        self.assertEqual(response, expected_response)
+        self.assertIs(grpc.StatusCode.OK, call.code())
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'server')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNone(span1)
+
+    def testStreamStreamOpenTracing(self):
+        multi_callable = self._service.stream_stream_multi_callable
+        requests = [b'\x01', b'\x02']
+        expected_response = self._service.handler.handle_stream_stream(
+            iter(requests), None)
+        response = multi_callable(iter(requests))
+
+        self.assertEqual(list(response), list(expected_response))
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertEqual(span0.get_tag('span.kind'), 'server')
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNone(span1)
+
+
+class OpenTracingErroringTest(unittest.TestCase):
+    """Test that tracer spans set the error tag when erroring RPC are invoked."""
+
+    def setUp(self):
+        self._tracer = Tracer()
+        self._service = Service([open_tracing_client_interceptor(self._tracer)],
+                                [open_tracing_server_interceptor(self._tracer)],
+                                ErroringHandler())
+
+    def testUnaryUnaryOpenTracing(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        self.assertRaises(grpc.RpcError, multi_callable, request)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertTrue(span0.get_tag('error'))
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertTrue(span1.get_tag('error'))
+
+    def testUnaryUnaryOpenTracingWithCall(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        self.assertRaises(grpc.RpcError, multi_callable.with_call, request)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertTrue(span0.get_tag('error'))
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertTrue(span1.get_tag('error'))
+
+    def testUnaryStreamOpenTracing(self):
+        multi_callable = self._service.unary_stream_multi_callable
+        request = b'\x01'
+        response = multi_callable(request)
+        self.assertRaises(grpc.RpcError, list, response)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertTrue(span0.get_tag('error'))
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertTrue(span1.get_tag('error'))
+
+    def testStreamUnaryOpenTracing(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        self.assertRaises(grpc.RpcError, multi_callable, iter(requests))
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertTrue(span0.get_tag('error'))
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertTrue(span1.get_tag('error'))
+
+    def testStreamUnaryOpenTracingWithCall(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        self.assertRaises(grpc.RpcError, multi_callable.with_call,
+                          iter(requests))
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertTrue(span0.get_tag('error'))
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertTrue(span1.get_tag('error'))
+
+    def testStreamStreamOpenTracing(self):
+        multi_callable = self._service.stream_stream_multi_callable
+        requests = [b'\x01', b'\x02']
+        response = multi_callable(iter(requests))
+        self.assertRaises(grpc.RpcError, list, response)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertTrue(span0.get_tag('error'))
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertTrue(span1.get_tag('error'))
+
+
+class OpenTracingExceptionErroringTest(unittest.TestCase):
+    """Test that tracer spans set the error tag when exception erroring RPC are 
+    invoked.
+  """
+
+    def setUp(self):
+        self._tracer = Tracer()
+        self._service = Service([open_tracing_client_interceptor(self._tracer)],
+                                [open_tracing_server_interceptor(self._tracer)],
+                                ExceptionErroringHandler())
+
+    def testUnaryUnaryOpenTracing(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        self.assertRaises(grpc.RpcError, multi_callable, request)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertTrue(span0.get_tag('error'))
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertTrue(span1.get_tag('error'))
+
+    def testUnaryUnaryOpenTracingWithCall(self):
+        multi_callable = self._service.unary_unary_multi_callable
+        request = b'\x01'
+        self.assertRaises(grpc.RpcError, multi_callable.with_call, request)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertTrue(span0.get_tag('error'))
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertTrue(span1.get_tag('error'))
+
+    def testUnaryStreamOpenTracing(self):
+        multi_callable = self._service.unary_stream_multi_callable
+        request = b'\x01'
+        response = multi_callable(request)
+        self.assertRaises(grpc.RpcError, list, response)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertTrue(span0.get_tag('error'))
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertTrue(span1.get_tag('error'))
+
+    def testStreamUnaryOpenTracing(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        self.assertRaises(grpc.RpcError, multi_callable, iter(requests))
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertTrue(span0.get_tag('error'))
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertTrue(span1.get_tag('error'))
+
+    def testStreamUnaryOpenTracingWithCall(self):
+        multi_callable = self._service.stream_unary_multi_callable
+        requests = [b'\x01', b'\x02']
+        self.assertRaises(grpc.RpcError, multi_callable.with_call,
+                          iter(requests))
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertTrue(span0.get_tag('error'))
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertTrue(span1.get_tag('error'))
+
+    def testStreamStreamOpenTracing(self):
+        multi_callable = self._service.stream_stream_multi_callable
+        requests = [b'\x01', b'\x02']
+        response = multi_callable(iter(requests))
+        self.assertRaises(grpc.RpcError, list, response)
+
+        span0 = self._tracer.get_span(0)
+        self.assertIsNotNone(span0)
+        self.assertTrue(span0.get_tag('error'))
+
+        span1 = self._tracer.get_span(1)
+        self.assertIsNotNone(span1)
+        self.assertTrue(span1.get_tag('error'))