Add files using upload-large-folder tool

.venv/lib/python3.11/site-packages/opencensus/metrics/label_value.py

@@ -0,0 +1,42 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class LabelValue(object):
+    """The label values associated with the TimeSeries.
+
+    :type value: str
+    :param value: the value for the label
+    """
+    def __init__(self, value=None):
+        self._value = value
+
+    def __repr__(self):
+        return ("{}({})"
+                .format(
+                    type(self).__name__,
+                    self.value,
+                ))
+
+    @property
+    def value(self):
+        """the value for the label"""
+        return self._value
+
+    def __eq__(self, other):
+        return isinstance(other, LabelValue) and \
+            self.value == other.value
+
+    def __hash__(self):
+        return hash(self.value)

.venv/lib/python3.11/site-packages/opencensus/tags/__init__.py

@@ -0,0 +1,23 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from opencensus.common.runtime_context import RuntimeContext
+from opencensus.tags.tag import Tag
+from opencensus.tags.tag_key import TagKey
+from opencensus.tags.tag_map import TagMap
+from opencensus.tags.tag_value import TagValue
+
+__all__ = ['Tag', 'TagContext', 'TagKey', 'TagValue', 'TagMap']
+
+TagContext = RuntimeContext.register_slot('tag_context', None)

.venv/lib/python3.11/site-packages/opencensus/tags/propagation/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

.venv/lib/python3.11/site-packages/opencensus/tags/propagation/binary_serializer.py

@@ -0,0 +1,109 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -*- coding: utf-8 -*-
+
+import six
+
+import logging
+
+from google.protobuf.internal.encoder import _VarintBytes
+
+from opencensus.tags import tag_map as tag_map_module
+
+# Used for decoding hex bytes to hex string.
+UTF8 = 'utf-8'
+
+VERSION_ID = 0
+TAG_FIELD_ID = 0
+TAG_MAP_SERIALIZED_SIZE_LIMIT = 8192
+
+
+class BinarySerializer(object):
+    def from_byte_array(self, binary):
+        if len(binary) <= 0:
+            logging.warning("Input byte[] cannot be empty/")
+            return tag_map_module.TagMap()
+        else:
+            buffer = memoryview(binary)
+            version_id = buffer[0]
+            if six.PY2:
+                version_id = ord(version_id)
+            if version_id != VERSION_ID:
+                raise ValueError("Invalid version id.")
+            return self._parse_tags(buffer)
+
+    def to_byte_array(self, tag_context):
+        encoded_bytes = b''
+        encoded_bytes += _VarintBytes(VERSION_ID)
+        total_chars = 0
+        for tag in tag_context:
+            tag_key, tag_value = tag
+            total_chars += len(tag_key)
+            total_chars += len(tag_value)
+            encoded_bytes = self._encode_tag(
+                tag_key, tag_value, encoded_bytes)
+        if total_chars <= TAG_MAP_SERIALIZED_SIZE_LIMIT:
+            return encoded_bytes
+        else:  # pragma: NO COVER
+            logging.warning("Size of the tag context exceeds the maximum size")
+
+    def _parse_tags(self, buffer):
+        tag_context = tag_map_module.TagMap()
+        limit = len(buffer)
+        total_chars = 0
+        i = 1
+        while i < limit:
+            field_id = buffer[i] if six.PY3 else ord(buffer[i])
+            if field_id == TAG_FIELD_ID:
+                i += 1
+                key = self._decode_string(buffer, i)
+                i += len(key)
+                total_chars += len(key)
+                i += 1
+                val = self._decode_string(buffer, i)
+                i += len(val)
+                total_chars += len(val)
+                i += 1
+                if total_chars > \
+                        TAG_MAP_SERIALIZED_SIZE_LIMIT:  # pragma: NO COVER
+                    logging.warning("Size of the tag context exceeds maximum")
+                    break
+                else:
+                    tag_context.insert(str(key), str(val))
+            else:
+                break
+        return tag_context
+
+    def _encode_tag(self, tag_key, tag_value, encoded_bytes):
+        encoded_bytes += _VarintBytes(TAG_FIELD_ID)
+        encoded_bytes = self._encode_string(tag_key, encoded_bytes)
+        encoded_bytes = self._encode_string(tag_value, encoded_bytes)
+        return encoded_bytes
+
+    def _encode_string(self, input_str, encoded_bytes):
+        encoded_bytes += _VarintBytes(len(input_str))
+        encoded_bytes += input_str.encode(UTF8)
+        return encoded_bytes
+
+    def _decode_string(self, buffer, pos):
+        length = buffer[pos] if six.PY3 else ord(buffer[pos])
+        builder = ""
+        i = 1
+        while i <= length:
+            bytes_to_decode = buffer[pos + i] if six.PY3 \
+                else ord(buffer[pos + i])
+            builder += _VarintBytes(bytes_to_decode).decode()
+            i += 1
+        return builder

.venv/lib/python3.11/site-packages/opencensus/tags/tag.py

@@ -0,0 +1,38 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections import namedtuple
+
+from opencensus.tags.tag_key import TagKey
+from opencensus.tags.tag_value import TagValue
+
+Tag_ = namedtuple('Tag', ['key', 'value'])
+
+
+class Tag(Tag_):
+    """A tag, in the format [KEY]:[VALUE].
+
+    :type key: str
+    :param key: The name of the tag
+
+    :type value: str
+    :param value: The value of the tag
+
+    """
+    def __new__(cls, key, value):
+        return super(Tag, cls).__new__(
+            cls,
+            key=TagKey(key),
+            value=TagValue(value),
+        )

.venv/lib/python3.11/site-packages/opencensus/tags/tag_key.py

@@ -0,0 +1,35 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from opencensus.tags.validation import is_valid_tag_name
+
+_TAG_NAME_ERROR = \
+    'tag name must not be empty,' \
+    'no longer than 255 characters and of ascii values between 32 - 126'
+
+
+class TagKey(str):
+    """A tag key with a property name"""
+
+    def __new__(cls, name):
+        """Create and return a new tag key
+
+        :type name: str
+        :param name: The name of the key
+        :return: TagKey
+        """
+        if not isinstance(name, cls):
+            if not is_valid_tag_name(name):
+                raise ValueError(_TAG_NAME_ERROR)
+        return super(TagKey, cls).__new__(cls, name)

.venv/lib/python3.11/site-packages/opencensus/tags/tag_map.py

@@ -0,0 +1,104 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections import OrderedDict
+
+from opencensus.tags.tag_key import TagKey
+from opencensus.tags.tag_value import TagValue
+
+
+class TagMap(object):
+    """ A tag map is a map of tags from key to value
+
+    :type tags: list(:class: '~opencensus.tags.tag.Tag')
+    :param tags: a list of tags
+
+    """
+
+    def __init__(self, tags=None):
+        self.map = OrderedDict(tags if tags else [])
+
+    def __iter__(self):
+        return self.map.items().__iter__()
+
+    def insert(self, key, value):
+        """Inserts a key and value in the map if the map does not already
+        contain the key.
+
+        :type key: :class: '~opencensus.tags.tag_key.TagKey'
+        :param key: a tag key to insert into the map
+
+        :type value: :class: '~opencensus.tags.tag_value.TagValue'
+        :param value: a tag value that is associated with the tag key and
+        the value to insert into the tag map
+
+        """
+        if key in self.map:
+            return
+
+        try:
+            tag_key = TagKey(key)
+            tag_val = TagValue(value)
+            self.map[tag_key] = tag_val
+        except ValueError:
+            raise
+
+    def delete(self, key):
+        """Deletes a tag from the map if the key is in the map
+
+        :type key: :class: '~opencensus.tags.tag_key.TagKey'
+        :param key: A string representing a possible tag key
+
+        :returns: the value of the key in the dictionary if it is in there,
+                  or None if it is not.
+        """
+        self.map.pop(key, None)
+
+    def update(self, key, value):
+        """Updates the map by updating the value of a key
+
+        :type key: :class: '~opencensus.tags.tag_key.TagKey'
+        :param key: A tag key to be updated
+
+        :type value: :class: '~opencensus.tags.tag_value.TagValue'
+        :param value: The value to update the key to in the map
+
+        """
+        if key in self.map:
+            self.map[key] = value
+
+    def tag_key_exists(self, key):
+        """Checking if the tag key exists in the map
+
+        :type key: '~opencensus.tags.tag_key.TagKey'
+        :param key: A string to check to see if that is a key in the map
+
+        :returns: True if the key is in map, False is it is not
+
+        """
+        return key in self.map
+
+    def get_value(self, key):
+        """ Gets the value of the key passed in if the key exists in the map
+
+        :type key: str
+        :param key: A string representing a key to get the value of in the map
+
+        :returns: A KeyError if the value is None, else returns the value
+
+        """
+        try:
+            return self.map[key]
+        except KeyError:
+            raise KeyError('key is not in map')

.venv/lib/python3.11/site-packages/opencensus/tags/tag_value.py

@@ -0,0 +1,35 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from opencensus.tags.validation import is_valid_tag_value
+
+_TAG_VALUE_ERROR = \
+    'tag value must not be longer than 255 characters ' \
+    'and of ascii values between 32 - 126'
+
+
+class TagValue(str):
+    """The value of a tag"""
+
+    def __new__(cls, value):
+        """Create and return a new tag value
+
+        :type value: str
+        :param value: A string representing the value of a key in a tag
+        :return: TagValue
+        """
+        if not isinstance(value, cls):
+            if not is_valid_tag_value(value):
+                raise ValueError(_TAG_VALUE_ERROR)
+        return super(TagValue, cls).__new__(cls, value)

.venv/lib/python3.11/site-packages/opencensus/tags/validation.py

@@ -0,0 +1,42 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def is_legal_chars(value):
+    return all(32 <= ord(char) <= 126 for char in value)
+
+
+def is_valid_tag_name(name):
+    """Checks if the name of a tag key is valid
+
+    :type name: str
+    :param name: name to check
+
+    :rtype: bool
+    :returns: True if it valid, else returns False
+    """
+    return is_legal_chars(name) if 0 < len(name) <= 255 else False
+
+
+def is_valid_tag_value(value):
+    """Checks if the value is valid
+
+    :type value: str
+    :param value: the value to be checked
+
+    :rtype: bool
+    :returns: True if valid, if not, False.
+
+    """
+    return is_legal_chars(value) if len(value) <= 255 else False

.venv/lib/python3.11/site-packages/opencensus/trace/__init__.py

@@ -0,0 +1,17 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from opencensus.trace.span import Span
+
+__all__ = ['Span']

.venv/lib/python3.11/site-packages/opencensus/trace/attributes.py

@@ -0,0 +1,74 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import six
+
+from opencensus.common import utils
+
+
+def _format_attribute_value(value):
+    if isinstance(value, bool):
+        value_type = 'bool_value'
+    elif isinstance(value, int):
+        value_type = 'int_value'
+    elif isinstance(value, six.string_types):
+        value_type = 'string_value'
+        value = utils.get_truncatable_str(value)
+    elif isinstance(value, float):
+        value_type = 'double_value'
+    else:
+        return None
+
+    return {value_type: value}
+
+
+class Attributes(object):
+    """A set of attributes, each in the format [KEY]:[VALUE].
+
+    :type attributes: dict
+    :param attributes: The set of attributes. Each attribute's key can be up
+                       to 128 bytes long. The value can be a string up to 256
+                       bytes, an integer, a floating-point number, or the
+                       Boolean values true and false.
+    """
+    def __init__(self, attributes=None):
+        self.attributes = attributes or {}
+
+    def set_attribute(self, key, value):
+        """Set a key value pair."""
+        self.attributes[key] = value
+
+    def delete_attribute(self, key):
+        """Delete an attribute given a key if existed."""
+        self.attributes.pop(key, None)
+
+    def get_attribute(self, key):
+        """Get a attribute value."""
+        return self.attributes.get(key, None)
+
+    def format_attributes_json(self):
+        """Convert the Attributes object to json format."""
+        attributes_json = {}
+
+        for key, value in self.attributes.items():
+            key = utils.check_str_length(key)[0]
+            value = _format_attribute_value(value)
+
+            if value is not None:
+                attributes_json[key] = value
+
+        result = {
+            'attributeMap': attributes_json
+        }
+
+        return result

.venv/lib/python3.11/site-packages/opencensus/trace/attributes_helper.py

@@ -0,0 +1,43 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+COMMON_ATTRIBUTES = {
+    'AGENT': 'g.co/agent',
+    'COMPONENT': 'component',
+    'ERROR_MESSAGE': 'error.message',
+    'ERROR_NAME': 'error.name',
+    'HTTP_CLIENT_CITY': 'http.client_city',
+    'HTTP_CLIENT_COUNTRY': 'http.client_country',
+    'HTTP_CLIENT_PROTOCOL': 'http.client_protocol',
+    'HTTP_CLIENT_REGION': 'http.client_region',
+    'HTTP_HOST': 'http.host',
+    'HTTP_METHOD': 'http.method',
+    'HTTP_PATH': 'http.path',
+    'HTTP_ROUTE': 'http.route',
+    'HTTP_REDIRECTED_URL': 'http.redirected_url',
+    'HTTP_REQUEST_SIZE': 'http.request_size',
+    'HTTP_RESPONSE_SIZE': 'http.response_size',
+    'HTTP_STATUS_CODE': 'http.status_code',
+    'HTTP_URL': 'http.url',
+    'HTTP_USER_AGENT': 'http.user_agent',
+    'PID': 'pid',
+    'STACKTRACE': 'stacktrace',
+    'TID': 'tid',
+}
+
+
+GRPC_ATTRIBUTES = {
+    'GRPC_HOST_PORT': 'grpc.host_port',
+    'GRPC_METHOD': 'grpc.method',
+}

.venv/lib/python3.11/site-packages/opencensus/trace/base_exporter.py

@@ -0,0 +1,43 @@
+# Copyright 2016-17, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Module containing base class for exporters."""
+
+
+class Exporter(object):
+    """Base class for opencensus trace request exporters.
+
+    Subclasses of :class:`Exporter` must override :meth:`export`.
+    """
+
+    def emit(self, span_datas):
+        """
+        :type span_datas: list of :class:
+            `~opencensus.trace.span_data.SpanData`
+        :param list of opencensus.trace.span_data.SpanData span_datas:
+            SpanData tuples to emit
+        """
+        raise NotImplementedError
+
+    def export(self, span_datas):
+        """Export the trace. Send trace to transport, and transport will call
+        exporter.emit() to actually send the trace to the specified tracing
+        backend.
+
+        :type span_datas: list of :class:
+            `~opencensus.trace.span_data.SpanData`
+        :param list of opencensus.trace.span_data.SpanData span_datas:
+            SpanData tuples to export
+        """
+        raise NotImplementedError

.venv/lib/python3.11/site-packages/opencensus/trace/base_span.py

@@ -0,0 +1,109 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Module containing base class for Span."""
+
+
+class BaseSpan(object):
+    """Base class for Opencensus spans.
+    Subclasses of :class:`BaseSpan` must implement the below methods.
+    """
+
+    @staticmethod
+    def on_create(callback):
+        raise NotImplementedError
+
+    @property
+    def children(self):
+        """The child spans of the current span."""
+        raise NotImplementedError
+
+    def span(self, name='child_span'):
+        """Create a child span for the current span and append it to the child
+        spans list.
+
+        :type name: str
+        :param name: (Optional) The name of the child span.
+
+        :rtype: :class: `~opencensus.trace.span.Span`
+        :returns: A child Span to be added to the current span.
+        """
+        raise NotImplementedError
+
+    def add_attribute(self, attribute_key, attribute_value):
+        """Add attribute to span.
+
+        :type attribute_key: str
+        :param attribute_key: Attribute key.
+
+        :type attribute_value:str
+        :param attribute_value: Attribute value.
+        """
+        raise NotImplementedError
+
+    def add_annotation(self, description, **attrs):
+        """Add an annotation to span.
+
+        :type description: str
+        :param description: A user-supplied message describing the event.
+                        The maximum length for the description is 256 bytes.
+
+        :type attrs: kwargs
+        :param attrs: keyworded arguments e.g. failed=True, name='Caching'
+        """
+        raise NotImplementedError
+
+    def add_message_event(self, message_event):
+        """Add a message event to this span.
+
+        :type message_event: :class:`opencensus.trace.time_event.MessageEvent`
+        :param message_event: The message event to attach to this span.
+        """
+        raise NotImplementedError
+
+    def add_link(self, link):
+        """Add a Link.
+
+        :type link: :class: `~opencensus.trace.link.Link`
+        :param link: A Link object.
+        """
+        raise NotImplementedError
+
+    def set_status(self, status):
+        """Sets span status.
+
+        :type code: :class: `~opencensus.trace.status.Status`
+        :param code: A Status object.
+        """
+        raise NotImplementedError
+
+    def start(self):
+        """Set the start time for a span."""
+        raise NotImplementedError
+
+    def finish(self):
+        """Set the end time for a span."""
+        raise NotImplementedError
+
+    def __iter__(self):
+        """Iterate through the span tree."""
+        raise NotImplementedError
+
+    def __enter__(self):
+        """Start a span."""
+        raise NotImplementedError
+
+    def __exit__(self, exception_type, exception_value, traceback):
+        """Finish a span."""
+        raise NotImplementedError

.venv/lib/python3.11/site-packages/opencensus/trace/blank_span.py

@@ -0,0 +1,165 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from opencensus.trace import base_span
+from opencensus.trace.span_context import generate_span_id
+from opencensus.trace.tracers import base
+
+
+class BlankSpan(base_span.BaseSpan):
+    """A BlankSpan is an individual timed event which forms a node of the trace
+    tree. All operations are no-op.
+
+    :type name: str
+    :param name: The name of the span.
+
+    :type parent_span: :class:`~opencensus.trace.blank_span.BlankSpan`
+    :param parent_span: (Optional) Parent span.
+
+    :type status: :class: `~opencensus.trace.status.Status`
+    :param status: (Optional) An optional final status for this span.
+
+    :type context_tracer: :class:`~opencensus.trace.tracers.noop_tracer.
+                                 NoopTracer`
+    :param context_tracer: The tracer that holds a stack of spans. If this is
+                           not None, then when exiting a span, use the end_span
+                           method in the tracer class to finish a span. If no
+                           tracer is passed in, then just finish the span using
+                           the finish method in the Span class.
+    """
+
+    def __init__(
+            self,
+            name=None,
+            parent_span=None,
+            attributes=None,
+            start_time=None,
+            end_time=None,
+            span_id=None,
+            stack_trace=None,
+            annotations=None,
+            message_events=None,
+            links=None,
+            status=None,
+            same_process_as_parent_span=None,
+            context_tracer=None,
+            span_kind=None):
+        self.name = name
+        self.parent_span = parent_span
+        self.start_time = start_time
+        self.end_time = end_time
+
+        self.span_id = generate_span_id()
+        self.parent_span = base.NullContextManager()
+
+        self.attributes = {}
+        self.stack_trace = stack_trace
+        self.annotations = annotations
+        self.message_events = message_events
+        self.links = []
+        self.status = status
+        self.same_process_as_parent_span = same_process_as_parent_span
+        self._child_spans = []
+        self.context_tracer = context_tracer
+        self.span_kind = span_kind
+
+    @staticmethod
+    def on_create(callback):
+        pass
+
+    @property
+    def children(self):
+        """The child spans of the current BlankSpan."""
+        return list()
+
+    def span(self, name='child_span'):
+        """Create a child span for the current span and append it to the child
+        spans list.
+
+        :type name: str
+        :param name: (Optional) The name of the child span.
+
+        :rtype: :class: `~opencensus.trace.blankspan.BlankSpan`
+        :returns: A child Span to be added to the current span.
+        """
+        child_span = BlankSpan(name, parent_span=self)
+        self._child_spans.append(child_span)
+        return child_span
+
+    def add_attribute(self, attribute_key, attribute_value):
+        """No-op implementation of this method.
+
+        :type attribute_key: str
+        :param attribute_key: Attribute key.
+
+        :type attribute_value:str
+        :param attribute_value: Attribute value.
+        """
+        pass
+
+    def add_annotation(self, description, **attrs):
+        """No-op implementation of this method.
+
+        :type description: str
+        :param description: A user-supplied message describing the event.
+                        The maximum length for the description is 256 bytes.
+
+        :type attrs: kwargs
+        :param attrs: keyworded arguments e.g. failed=True, name='Caching'
+        """
+        pass
+
+    def add_message_event(self, message_event):
+        """No-op implementation of this method.
+
+        :type message_event: :class:`opencensus.trace.time_event.MessageEvent`
+        :param message_event: The message event to attach to this span.
+        """
+        pass
+
+    def add_link(self, link):
+        """No-op implementation of this method.
+
+        :type link: :class: `~opencensus.trace.link.Link`
+        :param link: A Link object.
+        """
+        pass
+
+    def set_status(self, status):
+        """No-op implementation of this method.
+
+        :type code: :class: `~opencensus.trace.status.Status`
+        :param code: A Status object.
+        """
+        pass
+
+    def start(self):
+        """No-op implementation of this method."""
+        pass
+
+    def finish(self):
+        """No-op implementation of this method."""
+        pass
+
+    def __iter__(self):
+        """Iterate through the span tree."""
+        yield self
+
+    def __enter__(self):
+        """Start a span."""
+        return self
+
+    def __exit__(self, exception_type, exception_value, traceback):
+        """Finish a span."""
+        pass

.venv/lib/python3.11/site-packages/opencensus/trace/config_integration.py

@@ -0,0 +1,38 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import importlib
+import logging
+
+log = logging.getLogger(__name__)
+
+
+def trace_integrations(integrations, tracer=None):
+    """Enable tracing on the selected integrations.
+    :type integrations: list
+    :param integrations: The integrations to be traced.
+    """
+    integrated = []
+
+    for item in integrations:
+        module_name = 'opencensus.ext.{}.trace'.format(item)
+        try:
+            module = importlib.import_module(module_name)
+            module.trace_integration(tracer=tracer)
+            integrated.append(item)
+        except Exception as e:
+            log.warning('Failed to integrate module: {}'.format(module_name))
+            log.warning('{}'.format(e))
+
+    return integrated

.venv/lib/python3.11/site-packages/opencensus/trace/exceptions_status.py

@@ -0,0 +1,25 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from google.rpc import code_pb2
+
+from opencensus.trace.status import Status
+
+CANCELLED = Status(code_pb2.CANCELLED)
+INVALID_URL = Status(code_pb2.INVALID_ARGUMENT, message='invalid URL')
+TIMEOUT = Status(code_pb2.DEADLINE_EXCEEDED, message='request timed out')
+
+
+def unknown(exception):
+    return Status.from_exception(exception)

.venv/lib/python3.11/site-packages/opencensus/trace/execution_context.py

@@ -0,0 +1,89 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from opencensus.common.runtime_context import RuntimeContext
+from opencensus.trace.tracers import noop_tracer
+
+_attrs_slot = RuntimeContext.register_slot('attrs', lambda: {})
+_current_span_slot = RuntimeContext.register_slot('current_span', None)
+_exporter_slot = RuntimeContext.register_slot('is_exporter', False)
+_tracer_slot = RuntimeContext.register_slot('tracer', noop_tracer.NoopTracer())
+
+
+def is_exporter():
+    return RuntimeContext.is_exporter
+
+
+def set_is_exporter(is_exporter):
+    RuntimeContext.is_exporter = is_exporter
+
+
+def get_opencensus_tracer():
+    """Get the opencensus tracer from runtime context."""
+    return RuntimeContext.tracer
+
+
+def set_opencensus_tracer(tracer):
+    """Add the tracer to runtime context."""
+    RuntimeContext.tracer = tracer
+
+
+def set_opencensus_attr(attr_key, attr_value):
+    attrs = RuntimeContext.attrs.copy()
+    attrs[attr_key] = attr_value
+    RuntimeContext.attrs = attrs
+
+
+def set_opencensus_attrs(attrs):
+    RuntimeContext.attrs = attrs
+
+
+def get_opencensus_attr(attr_key):
+    return RuntimeContext.attrs.get(attr_key)
+
+
+def get_opencensus_attrs():
+    return RuntimeContext.attrs
+
+
+def get_current_span():
+    return RuntimeContext.current_span
+
+
+def set_current_span(current_span):
+    RuntimeContext.current_span = current_span
+
+
+def get_opencensus_full_context():
+    attrs = RuntimeContext.attrs
+    current_span = RuntimeContext.current_span
+    tracer = RuntimeContext.tracer
+    return tracer, current_span, attrs
+
+
+def set_opencensus_full_context(tracer, span, attrs):
+    set_opencensus_tracer(tracer)
+    set_current_span(span)
+    set_opencensus_attrs(attrs or {})
+
+
+def clean():
+    _attrs_slot.clear()
+    _current_span_slot.clear()
+    _tracer_slot.clear()
+
+
+def clear():
+    """Clear the context, used in test."""
+    clean()

.venv/lib/python3.11/site-packages/opencensus/trace/file_exporter.py

@@ -0,0 +1,71 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Export the trace spans to a local file."""
+
+import json
+
+from opencensus.common.transports import sync
+from opencensus.trace import base_exporter, span_data
+
+DEFAULT_FILENAME = 'opencensus-traces.json'
+
+
+class FileExporter(base_exporter.Exporter):
+    """
+    :type file_name: str
+    :param file_name: The name of the output file.
+
+    :type transport: :class:`type`
+    :param transport: Class for creating new transport objects. It should
+                      extend from the base_exporter :class:`.Transport` type
+                      and implement :meth:`.Transport.export`. Defaults to
+                      :class:`.SyncTransport`. The other option is
+                      :class:`.AsyncTransport`.
+
+    :type file_mode: str
+    :param file_mode: The file mode to open the output file with.
+                      Defaults to w+
+
+    """
+
+    def __init__(self, file_name=DEFAULT_FILENAME,
+                 transport=sync.SyncTransport,
+                 file_mode='w+'):
+        self.file_name = file_name
+        self.transport = transport(self)
+        self.file_mode = file_mode
+
+    def emit(self, span_datas):
+        """
+        :type span_datas: list of :class:
+            `~opencensus.trace.span_data.SpanData`
+        :param list of opencensus.trace.span_data.SpanData span_datas:
+            SpanData tuples to emit
+        """
+        with open(self.file_name, self.file_mode) as file:
+            # convert to the legacy trace json for easier refactoring
+            # TODO: refactor this to use the span data directly
+            legacy_trace_json = span_data.format_legacy_trace_json(span_datas)
+            trace_str = json.dumps(legacy_trace_json)
+            file.write(trace_str)
+
+    def export(self, span_datas):
+        """
+        :type span_datas: list of :class:
+            `~opencensus.trace.span_data.SpanData`
+        :param list of opencensus.trace.span_data.SpanData span_datas:
+            SpanData tuples to export
+        """
+        self.transport.export(span_datas)

.venv/lib/python3.11/site-packages/opencensus/trace/integrations.py

@@ -0,0 +1,52 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import threading
+
+_INTEGRATIONS_BIT_MASK = 0
+_INTEGRATIONS_LOCK = threading.Lock()
+
+
+class _Integrations:
+    NONE = 0
+    DJANGO = 1
+    FLASK = 2
+    GOOGLE_CLOUD = 4
+    HTTP_LIB = 8
+    LOGGING = 16
+    MYSQL = 32
+    POSTGRESQL = 64
+    PYMONGO = 128
+    PYMYSQL = 256
+    PYRAMID = 512
+    REQUESTS = 1024
+    SQLALCHEMY = 2056
+    HTTPX = 16777216
+    FASTAPI = 4194304
+
+
+def get_integrations():
+    return _INTEGRATIONS_BIT_MASK
+
+
+def add_integration(integration):
+    with _INTEGRATIONS_LOCK:
+        global _INTEGRATIONS_BIT_MASK  # pylint: disable=global-statement
+        _INTEGRATIONS_BIT_MASK |= integration
+
+
+def remove_intregration(integration):
+    with _INTEGRATIONS_LOCK:
+        global _INTEGRATIONS_BIT_MASK  # pylint: disable=global-statement
+        _INTEGRATIONS_BIT_MASK &= ~integration

.venv/lib/python3.11/site-packages/opencensus/trace/link.py

@@ -0,0 +1,71 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Type(object):
+    """The relationship of the current span relative to the linked span: child,
+    parent, or unspecified.
+
+    Attributes:
+      TYPE_UNSPECIFIED (int): The relationship of the two spans is unknown.
+      CHILD_LINKED_SPAN (int): The linked span is a child of the current span.
+      PARENT_LINKED_SPAN (int): The linked span is a parent of the current
+      span.
+    """
+    TYPE_UNSPECIFIED = 0
+    CHILD_LINKED_SPAN = 1
+    PARENT_LINKED_SPAN = 2
+
+
+class Link(object):
+    """A pointer from the current span to another span in the same trace or in
+    a different trace. For example, this can be used in batching operations,
+    where a single batch handler processes multiple requests from different
+    traces or when the handler receives a request from a different project.
+
+    :type trace_id: str
+    :param trace_id: The [TRACE_ID] for a trace within a project.
+
+    :type span_id: str
+    :param span_id: The [SPAN_ID] for a span within a trace.
+
+    :type type: Enum of :class:`~opencensus.trace.link.Type`
+    :param type: The relationship of the current span relative to the linked
+                 span.
+
+    :type attributes: :class:`~opencensus.trace.attributes.Attributes`
+    :param attributes: A set of attributes on the link. You have have up to 32
+                       attributes per link.
+    """
+    def __init__(self, trace_id, span_id, type=None, attributes=None):
+        self.trace_id = trace_id
+        self.span_id = span_id
+
+        if type is None:
+            type = Type.TYPE_UNSPECIFIED
+
+        self.type = type
+        self.attributes = attributes
+
+    def format_link_json(self):
+        """Convert a Link object to json format."""
+        link_json = {}
+        link_json['trace_id'] = self.trace_id
+        link_json['span_id'] = self.span_id
+        link_json['type'] = self.type
+
+        if self.attributes is not None:
+            link_json['attributes'] = self.attributes
+
+        return link_json

.venv/lib/python3.11/site-packages/opencensus/trace/logging_exporter.py

@@ -0,0 +1,85 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Export the spans data to python logging."""
+
+import logging
+
+from opencensus.common.transports import sync
+from opencensus.trace import base_exporter, span_data
+
+
+class LoggingExporter(base_exporter.Exporter):
+    """A exporter to export the spans data to python logging. Also can use
+    handlers like CloudLoggingHandler to log to Stackdriver Logging API.
+
+    :type handler: :class:`logging.handler`
+    :param handler: the handler to attach to the global handler
+
+    :type transport: :class:`type`
+    :param transport: Class for creating new transport objects. It should
+                      extend from the base_exporter :class:`.Transport` type
+                      and implement :meth:`.Transport.export`. Defaults to
+                      :class:`.SyncTransport`. The other option is
+                      :class:`.AsyncTransport`.
+
+    Example:
+
+    .. code-block:: python
+
+        import google.cloud.logging
+        from google.cloud.logging.handlers import CloudLoggingHandler
+        from opencensus.trace import logging_exporter
+
+        client = google.cloud.logging.Client()
+        cloud_handler = CloudLoggingHandler(client)
+        exporter = logging_exporter.LoggingExporter(handler=cloud_handler)
+
+        exporter.export(your_spans_list)
+
+    Or initialize a context tracer with the logging exporter, then the traces
+    will be exported to logging when finished.
+    """
+
+    def __init__(self, handler=None, transport=sync.SyncTransport):
+        self.logger = logging.getLogger()
+
+        if handler is None:
+            handler = logging.StreamHandler()
+
+        self.handler = handler
+        self.logger.addHandler(handler)
+        self.logger.setLevel(logging.INFO)
+        self.transport = transport(self)
+
+    def emit(self, span_datas):
+        """
+        :type span_datas: list of :class:
+            `~opencensus.trace.span_data.SpanData`
+        :param list of opencensus.trace.span_data.SpanData span_datas:
+            SpanData tuples to emit
+        """
+        # convert to the legacy trace json for easier refactoring
+        # TODO: refactor this to use the span data directly
+        legacy_trace_json = span_data.format_legacy_trace_json(span_datas)
+        self.logger.info(legacy_trace_json)
+
+    def export(self, span_datas):
+        """
+        :type span_datas: list of :class:
+            `~opencensus.trace.span_data.SpanData`
+        :param list of opencensus.trace.span_data.SpanData span_datas:
+            SpanData tuples to export
+        """
+        self.transport.export(span_datas)

.venv/lib/python3.11/site-packages/opencensus/trace/print_exporter.py

@@ -0,0 +1,51 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Export the trace spans by printing them out."""
+
+from opencensus.common.transports import sync
+from opencensus.trace import base_exporter
+
+
+class PrintExporter(base_exporter.Exporter):
+    """Export the spans by printing them.
+
+    :type transport: :class:`type`
+    :param transport: Class for creating new transport objects. It should
+                      extend from the base_exporter :class:`.Transport` type
+                      and implement :meth:`.Transport.export`. Defaults to
+                      :class:`.SyncTransport`. The other option is
+                      :class:`.AsyncTransport`.
+    """
+
+    def __init__(self, transport=sync.SyncTransport):
+        self.transport = transport(self)
+
+    def emit(self, span_datas):
+        """
+        :type span_datas: list of :class:
+            `~opencensus.trace.span_data.SpanData`
+        :param list of opencensus.trace.span_data.SpanData span_datas:
+            SpanData tuples to emit
+        """
+        print(span_datas)
+
+    def export(self, span_datas):
+        """
+        :type span_datas: list of :class:
+            `~opencensus.trace.span_data.SpanData`
+        :param list of opencensus.trace.span_data.SpanData span_datas:
+            SpanData tuples to export
+        """
+        self.transport.export(span_datas)

.venv/lib/python3.11/site-packages/opencensus/trace/propagation/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2017, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.