We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
`ddtrace.opentracer.span.Span` method return types not compliant with `opentracing.span.Span`
I'll be happy to submit a PR for this--it should be a small fix--but wanted to make sure this isn't a known issue first.

### Which version of dd-trace-py are you using?

0.59.0

### Which version of pip are you using?

22.0.3

### Explanation

`opentracing.span.Span` defines a handful of methods that return `self` for the instance their invoked on, in order to support call chaining.

`ddtrace.opentracer.span.Span` does not implement this interface for `set_tag` or `set_operation_name`.

https://github.com/DataDog/dd-trace-py/blob/1a6bad3ec2cbfffab0f83ebf5b72fe786b76dbed/ddtrace/opentracer/span.py#L137-L138
https://github.com/DataDog/dd-trace-py/blob/1a6bad3ec2cbfffab0f83ebf5b72fe786b76dbed/ddtrace/opentracer/span.py#L98-L99

See the `opentracing` interfaces for [set_tag](https://github.com/opentracing/opentracing-python/blob/1d495f7b1c89e3577c0ce4911ed2962c8dcf1482/opentracing/span.py#L120-L139) and [set_operation_name](https://github.com/opentracing/opentracing-python/blob/1d495f7b1c89e3577c0ce4911ed2962c8dcf1482/opentracing/span.py#L95-L104).


--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `ddtrace/opentracer/span.py`
Content:
```
1 import threading
2 from typing import Any
3 from typing import Dict
4 from typing import Optional
5 from typing import TYPE_CHECKING
6 from typing import Text
7 from typing import Union
8 
9 from opentracing import Span as OpenTracingSpan
10 from opentracing.ext import tags as OTTags
11 
12 from ddtrace.constants import ERROR_MSG
13 from ddtrace.constants import ERROR_STACK
14 from ddtrace.constants import ERROR_TYPE
15 from ddtrace.context import Context as DatadogContext
16 from ddtrace.internal.compat import NumericType
17 from ddtrace.span import Span as DatadogSpan
18 
19 from .span_context import SpanContext
20 from .tags import Tags
21 
22 
23 if TYPE_CHECKING:
24     from .tracer import Tracer
25 
26 
27 _TagNameType = Union[Text, bytes]
28 
29 
30 class Span(OpenTracingSpan):
31     """Datadog implementation of :class:`opentracing.Span`"""
32 
33     def __init__(self, tracer, context, operation_name):
34         # type: (Tracer, Optional[SpanContext], str) -> None
35         if context is not None:
36             context = SpanContext(ddcontext=context._dd_context, baggage=context.baggage)
37         else:
38             context = SpanContext()
39 
40         super(Span, self).__init__(tracer, context)
41 
42         self.finished = False
43         self._lock = threading.Lock()
44         # use a datadog span
45         self._dd_span = DatadogSpan(operation_name, context=context._dd_context)
46 
47     def finish(self, finish_time=None):
48         # type: (Optional[float]) -> None
49         """Finish the span.
50 
51         This calls finish on the ddspan.
52 
53         :param finish_time: specify a custom finish time with a unix timestamp
54             per time.time()
55         :type timestamp: float
56         """
57         if self.finished:
58             return
59 
60         # finish the datadog span
61         self._dd_span.finish(finish_time)
62         self.finished = True
63 
64     def set_baggage_item(self, key, value):
65         # type: (str, Any) -> Span
66         """Sets a baggage item in the span context of this span.
67 
68         Baggage is used to propagate state between spans.
69 
70         :param key: baggage item key
71         :type key: str
72 
73         :param value: baggage item value
74         :type value: a type that can be compat.stringify()'d
75 
76         :rtype: Span
77         :return: itself for chaining calls
78         """
79         new_ctx = self.context.with_baggage_item(key, value)
80         with self._lock:
81             self._context = new_ctx
82         return self
83 
84     def get_baggage_item(self, key):
85         # type: (str) -> Optional[str]
86         """Gets a baggage item from the span context of this span.
87 
88         :param key: baggage item key
89         :type key: str
90 
91         :rtype: str
92         :return: the baggage value for the given key or ``None``.
93         """
94         return self.context.get_baggage_item(key)
95 
96     def set_operation_name(self, operation_name):
97         # type: (str) -> None
98         """Set the operation name."""
99         self._dd_span.name = operation_name
100 
101     def log_kv(self, key_values, timestamp=None):
102         # type: (Dict[_TagNameType, Any], Optional[float]) -> Span
103         """Add a log record to this span.
104 
105         Passes on relevant opentracing key values onto the datadog span.
106 
107         :param key_values: a dict of string keys and values of any type
108         :type key_values: dict
109 
110         :param timestamp: a unix timestamp per time.time()
111         :type timestamp: float
112 
113         :return: the span itself, for call chaining
114         :rtype: Span
115         """
116 
117         # match opentracing defined keys to datadog functionality
118         # opentracing/specification/blob/1be630515dafd4d2a468d083300900f89f28e24d/semantic_conventions.md#log-fields-table
119         for key, val in key_values.items():
120             if key == "event" and val == "error":
121                 # TODO: not sure if it's actually necessary to set the error manually
122                 self._dd_span.error = 1
123                 self.set_tag("error", 1)
124             elif key == "error" or key == "error.object":
125                 self.set_tag(ERROR_TYPE, val)
126             elif key == "message":
127                 self.set_tag(ERROR_MSG, val)
128             elif key == "stack":
129                 self.set_tag(ERROR_STACK, val)
130             else:
131                 pass
132 
133         return self
134 
135     def set_tag(self, key, value):
136         # type: (_TagNameType, Any) -> None
137         """Set a tag on the span.
138 
139         This sets the tag on the underlying datadog span.
140         """
141         if key == Tags.SPAN_TYPE:
142             self._dd_span.span_type = value
143         elif key == Tags.SERVICE_NAME:
144             self._dd_span.service = value
145         elif key == Tags.RESOURCE_NAME or key == OTTags.DATABASE_STATEMENT:
146             self._dd_span.resource = value
147         elif key == OTTags.PEER_HOSTNAME:
148             self._dd_span.set_tag(Tags.TARGET_HOST, value)
149         elif key == OTTags.PEER_PORT:
150             self._dd_span.set_tag(Tags.TARGET_PORT, value)
151         elif key == Tags.SAMPLING_PRIORITY:
152             self._dd_span.context.sampling_priority = value
153         else:
154             self._dd_span.set_tag(key, value)
155 
156     def _get_tag(self, key):
157         # type: (_TagNameType) -> Optional[Text]
158         """Gets a tag from the span.
159 
160         This method retrieves the tag from the underlying datadog span.
161         """
162         return self._dd_span.get_tag(key)
163 
164     def _get_metric(self, key):
165         # type: (_TagNameType) -> Optional[NumericType]
166         """Gets a metric from the span.
167 
168         This method retrieves the metric from the underlying datadog span.
169         """
170         return self._dd_span.get_metric(key)
171 
172     def __enter__(self):
173         return self
174 
175     def __exit__(self, exc_type, exc_val, exc_tb):
176         if exc_type:
177             self._dd_span.set_exc_info(exc_type, exc_val, exc_tb)
178 
179         # note: self.finish() AND _dd_span.__exit__ will call _span.finish() but
180         # it is idempotent
181         self._dd_span.__exit__(exc_type, exc_val, exc_tb)
182         self.finish()
183 
184     def _associate_dd_span(self, ddspan):
185         # type: (DatadogSpan) -> None
186         """Associates a DD span with this span."""
187         # get the datadog span context
188         self._dd_span = ddspan
189         self.context._dd_context = ddspan.context
190 
191     @property
192     def _dd_context(self):
193         # type: () -> DatadogContext
194         return self._dd_span.context
195
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/ddtrace/opentracer/span.py b/ddtrace/opentracer/span.py
--- a/ddtrace/opentracer/span.py
+++ b/ddtrace/opentracer/span.py
@@ -94,9 +94,10 @@
         return self.context.get_baggage_item(key)
 
     def set_operation_name(self, operation_name):
-        # type: (str) -> None
+        # type: (str) -> Span
         """Set the operation name."""
         self._dd_span.name = operation_name
+        return self
 
     def log_kv(self, key_values, timestamp=None):
         # type: (Dict[_TagNameType, Any], Optional[float]) -> Span
@@ -133,7 +134,7 @@
         return self
 
     def set_tag(self, key, value):
-        # type: (_TagNameType, Any) -> None
+        # type: (_TagNameType, Any) -> Span
         """Set a tag on the span.
 
         This sets the tag on the underlying datadog span.
@@ -152,6 +153,7 @@
             self._dd_span.context.sampling_priority = value
         else:
             self._dd_span.set_tag(key, value)
+        return self
 
     def _get_tag(self, key):
         # type: (_TagNameType) -> Optional[Text]

{"golden_diff": "diff --git a/ddtrace/opentracer/span.py b/ddtrace/opentracer/span.py\n--- a/ddtrace/opentracer/span.py\n+++ b/ddtrace/opentracer/span.py\n@@ -94,9 +94,10 @@\n         return self.context.get_baggage_item(key)\n \n     def set_operation_name(self, operation_name):\n-        # type: (str) -> None\n+        # type: (str) -> Span\n         \"\"\"Set the operation name.\"\"\"\n         self._dd_span.name = operation_name\n+        return self\n \n     def log_kv(self, key_values, timestamp=None):\n         # type: (Dict[_TagNameType, Any], Optional[float]) -> Span\n@@ -133,7 +134,7 @@\n         return self\n \n     def set_tag(self, key, value):\n-        # type: (_TagNameType, Any) -> None\n+        # type: (_TagNameType, Any) -> Span\n         \"\"\"Set a tag on the span.\n \n         This sets the tag on the underlying datadog span.\n@@ -152,6 +153,7 @@\n             self._dd_span.context.sampling_priority = value\n         else:\n             self._dd_span.set_tag(key, value)\n+        return self\n \n     def _get_tag(self, key):\n         # type: (_TagNameType) -> Optional[Text]\n", "issue": "`ddtrace.opentracer.span.Span` method return types not compliant with `opentracing.span.Span`\nI'll be happy to submit a PR for this--it should be a small fix--but wanted to make sure this isn't a known issue first.\r\n\r\n### Which version of dd-trace-py are you using?\r\n\r\n0.59.0\r\n\r\n### Which version of pip are you using?\r\n\r\n22.0.3\r\n\r\n### Explanation\r\n\r\n`opentracing.span.Span` defines a handful of methods that return `self` for the instance their invoked on, in order to support call chaining.\r\n\r\n`ddtrace.opentracer.span.Span` does not implement this interface for `set_tag` or `set_operation_name`.\r\n\r\nhttps://github.com/DataDog/dd-trace-py/blob/1a6bad3ec2cbfffab0f83ebf5b72fe786b76dbed/ddtrace/opentracer/span.py#L137-L138\r\nhttps://github.com/DataDog/dd-trace-py/blob/1a6bad3ec2cbfffab0f83ebf5b72fe786b76dbed/ddtrace/opentracer/span.py#L98-L99\r\n\r\nSee the `opentracing` interfaces for [set_tag](https://github.com/opentracing/opentracing-python/blob/1d495f7b1c89e3577c0ce4911ed2962c8dcf1482/opentracing/span.py#L120-L139) and [set_operation_name](https://github.com/opentracing/opentracing-python/blob/1d495f7b1c89e3577c0ce4911ed2962c8dcf1482/opentracing/span.py#L95-L104).\r\n\n", "before_files": [{"content": "import threading\nfrom typing import Any\nfrom typing import Dict\nfrom typing import Optional\nfrom typing import TYPE_CHECKING\nfrom typing import Text\nfrom typing import Union\n\nfrom opentracing import Span as OpenTracingSpan\nfrom opentracing.ext import tags as OTTags\n\nfrom ddtrace.constants import ERROR_MSG\nfrom ddtrace.constants import ERROR_STACK\nfrom ddtrace.constants import ERROR_TYPE\nfrom ddtrace.context import Context as DatadogContext\nfrom ddtrace.internal.compat import NumericType\nfrom ddtrace.span import Span as DatadogSpan\n\nfrom .span_context import SpanContext\nfrom .tags import Tags\n\n\nif TYPE_CHECKING:\n    from .tracer import Tracer\n\n\n_TagNameType = Union[Text, bytes]\n\n\nclass Span(OpenTracingSpan):\n    \"\"\"Datadog implementation of :class:`opentracing.Span`\"\"\"\n\n    def __init__(self, tracer, context, operation_name):\n        # type: (Tracer, Optional[SpanContext], str) -> None\n        if context is not None:\n            context = SpanContext(ddcontext=context._dd_context, baggage=context.baggage)\n        else:\n            context = SpanContext()\n\n        super(Span, self).__init__(tracer, context)\n\n        self.finished = False\n        self._lock = threading.Lock()\n        # use a datadog span\n        self._dd_span = DatadogSpan(operation_name, context=context._dd_context)\n\n    def finish(self, finish_time=None):\n        # type: (Optional[float]) -> None\n        \"\"\"Finish the span.\n\n        This calls finish on the ddspan.\n\n        :param finish_time: specify a custom finish time with a unix timestamp\n            per time.time()\n        :type timestamp: float\n        \"\"\"\n        if self.finished:\n            return\n\n        # finish the datadog span\n        self._dd_span.finish(finish_time)\n        self.finished = True\n\n    def set_baggage_item(self, key, value):\n        # type: (str, Any) -> Span\n        \"\"\"Sets a baggage item in the span context of this span.\n\n        Baggage is used to propagate state between spans.\n\n        :param key: baggage item key\n        :type key: str\n\n        :param value: baggage item value\n        :type value: a type that can be compat.stringify()'d\n\n        :rtype: Span\n        :return: itself for chaining calls\n        \"\"\"\n        new_ctx = self.context.with_baggage_item(key, value)\n        with self._lock:\n            self._context = new_ctx\n        return self\n\n    def get_baggage_item(self, key):\n        # type: (str) -> Optional[str]\n        \"\"\"Gets a baggage item from the span context of this span.\n\n        :param key: baggage item key\n        :type key: str\n\n        :rtype: str\n        :return: the baggage value for the given key or ``None``.\n        \"\"\"\n        return self.context.get_baggage_item(key)\n\n    def set_operation_name(self, operation_name):\n        # type: (str) -> None\n        \"\"\"Set the operation name.\"\"\"\n        self._dd_span.name = operation_name\n\n    def log_kv(self, key_values, timestamp=None):\n        # type: (Dict[_TagNameType, Any], Optional[float]) -> Span\n        \"\"\"Add a log record to this span.\n\n        Passes on relevant opentracing key values onto the datadog span.\n\n        :param key_values: a dict of string keys and values of any type\n        :type key_values: dict\n\n        :param timestamp: a unix timestamp per time.time()\n        :type timestamp: float\n\n        :return: the span itself, for call chaining\n        :rtype: Span\n        \"\"\"\n\n        # match opentracing defined keys to datadog functionality\n        # opentracing/specification/blob/1be630515dafd4d2a468d083300900f89f28e24d/semantic_conventions.md#log-fields-table\n        for key, val in key_values.items():\n            if key == \"event\" and val == \"error\":\n                # TODO: not sure if it's actually necessary to set the error manually\n                self._dd_span.error = 1\n                self.set_tag(\"error\", 1)\n            elif key == \"error\" or key == \"error.object\":\n                self.set_tag(ERROR_TYPE, val)\n            elif key == \"message\":\n                self.set_tag(ERROR_MSG, val)\n            elif key == \"stack\":\n                self.set_tag(ERROR_STACK, val)\n            else:\n                pass\n\n        return self\n\n    def set_tag(self, key, value):\n        # type: (_TagNameType, Any) -> None\n        \"\"\"Set a tag on the span.\n\n        This sets the tag on the underlying datadog span.\n        \"\"\"\n        if key == Tags.SPAN_TYPE:\n            self._dd_span.span_type = value\n        elif key == Tags.SERVICE_NAME:\n            self._dd_span.service = value\n        elif key == Tags.RESOURCE_NAME or key == OTTags.DATABASE_STATEMENT:\n            self._dd_span.resource = value\n        elif key == OTTags.PEER_HOSTNAME:\n            self._dd_span.set_tag(Tags.TARGET_HOST, value)\n        elif key == OTTags.PEER_PORT:\n            self._dd_span.set_tag(Tags.TARGET_PORT, value)\n        elif key == Tags.SAMPLING_PRIORITY:\n            self._dd_span.context.sampling_priority = value\n        else:\n            self._dd_span.set_tag(key, value)\n\n    def _get_tag(self, key):\n        # type: (_TagNameType) -> Optional[Text]\n        \"\"\"Gets a tag from the span.\n\n        This method retrieves the tag from the underlying datadog span.\n        \"\"\"\n        return self._dd_span.get_tag(key)\n\n    def _get_metric(self, key):\n        # type: (_TagNameType) -> Optional[NumericType]\n        \"\"\"Gets a metric from the span.\n\n        This method retrieves the metric from the underlying datadog span.\n        \"\"\"\n        return self._dd_span.get_metric(key)\n\n    def __enter__(self):\n        return self\n\n    def __exit__(self, exc_type, exc_val, exc_tb):\n        if exc_type:\n            self._dd_span.set_exc_info(exc_type, exc_val, exc_tb)\n\n        # note: self.finish() AND _dd_span.__exit__ will call _span.finish() but\n        # it is idempotent\n        self._dd_span.__exit__(exc_type, exc_val, exc_tb)\n        self.finish()\n\n    def _associate_dd_span(self, ddspan):\n        # type: (DatadogSpan) -> None\n        \"\"\"Associates a DD span with this span.\"\"\"\n        # get the datadog span context\n        self._dd_span = ddspan\n        self.context._dd_context = ddspan.context\n\n    @property\n    def _dd_context(self):\n        # type: () -> DatadogContext\n        return self._dd_span.context\n", "path": "ddtrace/opentracer/span.py"}], "after_files": [{"content": "import threading\nfrom typing import Any\nfrom typing import Dict\nfrom typing import Optional\nfrom typing import TYPE_CHECKING\nfrom typing import Text\nfrom typing import Union\n\nfrom opentracing import Span as OpenTracingSpan\nfrom opentracing.ext import tags as OTTags\n\nfrom ddtrace.constants import ERROR_MSG\nfrom ddtrace.constants import ERROR_STACK\nfrom ddtrace.constants import ERROR_TYPE\nfrom ddtrace.context import Context as DatadogContext\nfrom ddtrace.internal.compat import NumericType\nfrom ddtrace.span import Span as DatadogSpan\n\nfrom .span_context import SpanContext\nfrom .tags import Tags\n\n\nif TYPE_CHECKING:\n    from .tracer import Tracer\n\n\n_TagNameType = Union[Text, bytes]\n\n\nclass Span(OpenTracingSpan):\n    \"\"\"Datadog implementation of :class:`opentracing.Span`\"\"\"\n\n    def __init__(self, tracer, context, operation_name):\n        # type: (Tracer, Optional[SpanContext], str) -> None\n        if context is not None:\n            context = SpanContext(ddcontext=context._dd_context, baggage=context.baggage)\n        else:\n            context = SpanContext()\n\n        super(Span, self).__init__(tracer, context)\n\n        self.finished = False\n        self._lock = threading.Lock()\n        # use a datadog span\n        self._dd_span = DatadogSpan(operation_name, context=context._dd_context)\n\n    def finish(self, finish_time=None):\n        # type: (Optional[float]) -> None\n        \"\"\"Finish the span.\n\n        This calls finish on the ddspan.\n\n        :param finish_time: specify a custom finish time with a unix timestamp\n            per time.time()\n        :type timestamp: float\n        \"\"\"\n        if self.finished:\n            return\n\n        # finish the datadog span\n        self._dd_span.finish(finish_time)\n        self.finished = True\n\n    def set_baggage_item(self, key, value):\n        # type: (str, Any) -> Span\n        \"\"\"Sets a baggage item in the span context of this span.\n\n        Baggage is used to propagate state between spans.\n\n        :param key: baggage item key\n        :type key: str\n\n        :param value: baggage item value\n        :type value: a type that can be compat.stringify()'d\n\n        :rtype: Span\n        :return: itself for chaining calls\n        \"\"\"\n        new_ctx = self.context.with_baggage_item(key, value)\n        with self._lock:\n            self._context = new_ctx\n        return self\n\n    def get_baggage_item(self, key):\n        # type: (str) -> Optional[str]\n        \"\"\"Gets a baggage item from the span context of this span.\n\n        :param key: baggage item key\n        :type key: str\n\n        :rtype: str\n        :return: the baggage value for the given key or ``None``.\n        \"\"\"\n        return self.context.get_baggage_item(key)\n\n    def set_operation_name(self, operation_name):\n        # type: (str) -> Span\n        \"\"\"Set the operation name.\"\"\"\n        self._dd_span.name = operation_name\n        return self\n\n    def log_kv(self, key_values, timestamp=None):\n        # type: (Dict[_TagNameType, Any], Optional[float]) -> Span\n        \"\"\"Add a log record to this span.\n\n        Passes on relevant opentracing key values onto the datadog span.\n\n        :param key_values: a dict of string keys and values of any type\n        :type key_values: dict\n\n        :param timestamp: a unix timestamp per time.time()\n        :type timestamp: float\n\n        :return: the span itself, for call chaining\n        :rtype: Span\n        \"\"\"\n\n        # match opentracing defined keys to datadog functionality\n        # opentracing/specification/blob/1be630515dafd4d2a468d083300900f89f28e24d/semantic_conventions.md#log-fields-table\n        for key, val in key_values.items():\n            if key == \"event\" and val == \"error\":\n                # TODO: not sure if it's actually necessary to set the error manually\n                self._dd_span.error = 1\n                self.set_tag(\"error\", 1)\n            elif key == \"error\" or key == \"error.object\":\n                self.set_tag(ERROR_TYPE, val)\n            elif key == \"message\":\n                self.set_tag(ERROR_MSG, val)\n            elif key == \"stack\":\n                self.set_tag(ERROR_STACK, val)\n            else:\n                pass\n\n        return self\n\n    def set_tag(self, key, value):\n        # type: (_TagNameType, Any) -> Span\n        \"\"\"Set a tag on the span.\n\n        This sets the tag on the underlying datadog span.\n        \"\"\"\n        if key == Tags.SPAN_TYPE:\n            self._dd_span.span_type = value\n        elif key == Tags.SERVICE_NAME:\n            self._dd_span.service = value\n        elif key == Tags.RESOURCE_NAME or key == OTTags.DATABASE_STATEMENT:\n            self._dd_span.resource = value\n        elif key == OTTags.PEER_HOSTNAME:\n            self._dd_span.set_tag(Tags.TARGET_HOST, value)\n        elif key == OTTags.PEER_PORT:\n            self._dd_span.set_tag(Tags.TARGET_PORT, value)\n        elif key == Tags.SAMPLING_PRIORITY:\n            self._dd_span.context.sampling_priority = value\n        else:\n            self._dd_span.set_tag(key, value)\n        return self\n\n    def _get_tag(self, key):\n        # type: (_TagNameType) -> Optional[Text]\n        \"\"\"Gets a tag from the span.\n\n        This method retrieves the tag from the underlying datadog span.\n        \"\"\"\n        return self._dd_span.get_tag(key)\n\n    def _get_metric(self, key):\n        # type: (_TagNameType) -> Optional[NumericType]\n        \"\"\"Gets a metric from the span.\n\n        This method retrieves the metric from the underlying datadog span.\n        \"\"\"\n        return self._dd_span.get_metric(key)\n\n    def __enter__(self):\n        return self\n\n    def __exit__(self, exc_type, exc_val, exc_tb):\n        if exc_type:\n            self._dd_span.set_exc_info(exc_type, exc_val, exc_tb)\n\n        # note: self.finish() AND _dd_span.__exit__ will call _span.finish() but\n        # it is idempotent\n        self._dd_span.__exit__(exc_type, exc_val, exc_tb)\n        self.finish()\n\n    def _associate_dd_span(self, ddspan):\n        # type: (DatadogSpan) -> None\n        \"\"\"Associates a DD span with this span.\"\"\"\n        # get the datadog span context\n        self._dd_span = ddspan\n        self.context._dd_context = ddspan.context\n\n    @property\n    def _dd_context(self):\n        # type: () -> DatadogContext\n        return self._dd_span.context\n", "path": "ddtrace/opentracer/span.py"}]}