Add files using upload-large-folder tool

vllm/lib/python3.10/site-packages/anyio-4.7.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

vllm/lib/python3.10/site-packages/anyio-4.7.0.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.1
+Name: anyio
+Version: 4.7.0
+Summary: High level compatibility layer for multiple asynchronous event loop implementations
+Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
+License: MIT
+Project-URL: Documentation, https://anyio.readthedocs.io/en/latest/
+Project-URL: Changelog, https://anyio.readthedocs.io/en/stable/versionhistory.html
+Project-URL: Source code, https://github.com/agronholm/anyio
+Project-URL: Issue tracker, https://github.com/agronholm/anyio/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Framework :: AnyIO
+Classifier: Typing :: Typed
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: exceptiongroup>=1.0.2; python_version < "3.11"
+Requires-Dist: idna>=2.8
+Requires-Dist: sniffio>=1.1
+Requires-Dist: typing_extensions>=4.5; python_version < "3.13"
+Provides-Extra: trio
+Requires-Dist: trio>=0.26.1; extra == "trio"
+Provides-Extra: test
+Requires-Dist: anyio[trio]; extra == "test"
+Requires-Dist: coverage[toml]>=7; extra == "test"
+Requires-Dist: exceptiongroup>=1.2.0; extra == "test"
+Requires-Dist: hypothesis>=4.0; extra == "test"
+Requires-Dist: psutil>=5.9; extra == "test"
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-mock>=3.6.1; extra == "test"
+Requires-Dist: trustme; extra == "test"
+Requires-Dist: truststore>=0.9.1; python_version >= "3.10" and extra == "test"
+Requires-Dist: uvloop>=0.21; (platform_python_implementation == "CPython" and platform_system != "Windows") and extra == "test"
+Provides-Extra: doc
+Requires-Dist: packaging; extra == "doc"
+Requires-Dist: Sphinx~=7.4; extra == "doc"
+Requires-Dist: sphinx_rtd_theme; extra == "doc"
+Requires-Dist: sphinx-autodoc-typehints>=1.2.0; extra == "doc"
+
+.. image:: https://github.com/agronholm/anyio/actions/workflows/test.yml/badge.svg
+  :target: https://github.com/agronholm/anyio/actions/workflows/test.yml
+  :alt: Build Status
+.. image:: https://coveralls.io/repos/github/agronholm/anyio/badge.svg?branch=master
+  :target: https://coveralls.io/github/agronholm/anyio?branch=master
+  :alt: Code Coverage
+.. image:: https://readthedocs.org/projects/anyio/badge/?version=latest
+  :target: https://anyio.readthedocs.io/en/latest/?badge=latest
+  :alt: Documentation
+.. image:: https://badges.gitter.im/gitterHQ/gitter.svg
+  :target: https://gitter.im/python-trio/AnyIO
+  :alt: Gitter chat
+
+AnyIO is an asynchronous networking and concurrency library that works on top of either asyncio_ or
+trio_. It implements trio-like `structured concurrency`_ (SC) on top of asyncio and works in harmony
+with the native SC of trio itself.
+
+Applications and libraries written against AnyIO's API will run unmodified on either asyncio_ or
+trio_. AnyIO can also be adopted into a library or application incrementally – bit by bit, no full
+refactoring necessary. It will blend in with the native libraries of your chosen backend.
+
+Documentation
+-------------
+
+View full documentation at: https://anyio.readthedocs.io/
+
+Features
+--------
+
+AnyIO offers the following functionality:
+
+* Task groups (nurseries_ in trio terminology)
+* High-level networking (TCP, UDP and UNIX sockets)
+
+  * `Happy eyeballs`_ algorithm for TCP connections (more robust than that of asyncio on Python
+    3.8)
+  * async/await style UDP sockets (unlike asyncio where you still have to use Transports and
+    Protocols)
+
+* A versatile API for byte streams and object streams
+* Inter-task synchronization and communication (locks, conditions, events, semaphores, object
+  streams)
+* Worker threads
+* Subprocesses
+* Asynchronous file I/O (using worker threads)
+* Signal handling
+
+AnyIO also comes with its own pytest_ plugin which also supports asynchronous fixtures.
+It even works with the popular Hypothesis_ library.
+
+.. _asyncio: https://docs.python.org/3/library/asyncio.html
+.. _trio: https://github.com/python-trio/trio
+.. _structured concurrency: https://en.wikipedia.org/wiki/Structured_concurrency
+.. _nurseries: https://trio.readthedocs.io/en/stable/reference-core.html#nurseries-and-spawning
+.. _Happy eyeballs: https://en.wikipedia.org/wiki/Happy_Eyeballs
+.. _pytest: https://docs.pytest.org/en/latest/
+.. _Hypothesis: https://hypothesis.works/

vllm/lib/python3.10/site-packages/anyio-4.7.0.dist-info/RECORD

@@ -0,0 +1,85 @@
+anyio-4.7.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+anyio-4.7.0.dist-info/LICENSE,sha256=U2GsncWPLvX9LpsJxoKXwX8ElQkJu8gCO9uC6s8iwrA,1081
+anyio-4.7.0.dist-info/METADATA,sha256=A-A-n0m-esMw8lYv8a9kqsr84J2aFh8MvqcTq2Xx_so,4653
+anyio-4.7.0.dist-info/RECORD,,
+anyio-4.7.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio-4.7.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+anyio-4.7.0.dist-info/entry_points.txt,sha256=_d6Yu6uiaZmNe0CydowirE9Cmg7zUL2g08tQpoS3Qvc,39
+anyio-4.7.0.dist-info/top_level.txt,sha256=QglSMiWX8_5dpoVAEIHdEYzvqFMdSYWmCj6tYw2ITkQ,6
+anyio/__init__.py,sha256=5NCKQNJueCeIJqVbOpAQdho2HIQrQvcnfQjuEhAiZcc,4433
+anyio/__pycache__/__init__.cpython-310.pyc,,
+anyio/__pycache__/from_thread.cpython-310.pyc,,
+anyio/__pycache__/lowlevel.cpython-310.pyc,,
+anyio/__pycache__/pytest_plugin.cpython-310.pyc,,
+anyio/__pycache__/to_process.cpython-310.pyc,,
+anyio/__pycache__/to_thread.cpython-310.pyc,,
+anyio/_backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_backends/__pycache__/__init__.cpython-310.pyc,,
+anyio/_backends/__pycache__/_asyncio.cpython-310.pyc,,
+anyio/_backends/__pycache__/_trio.cpython-310.pyc,,
+anyio/_backends/_asyncio.py,sha256=i5Qe4IBdiWRlww0qIUAVsF-K0z30bgZakuMePpNbdro,94051
+anyio/_backends/_trio.py,sha256=7oGxbqeveiesGm2pAnCRBydqy-Gbistn_xfsmKhSLLg,40371
+anyio/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_core/__pycache__/__init__.cpython-310.pyc,,
+anyio/_core/__pycache__/_asyncio_selector_thread.cpython-310.pyc,,
+anyio/_core/__pycache__/_eventloop.cpython-310.pyc,,
+anyio/_core/__pycache__/_exceptions.cpython-310.pyc,,
+anyio/_core/__pycache__/_fileio.cpython-310.pyc,,
+anyio/_core/__pycache__/_resources.cpython-310.pyc,,
+anyio/_core/__pycache__/_signals.cpython-310.pyc,,
+anyio/_core/__pycache__/_sockets.cpython-310.pyc,,
+anyio/_core/__pycache__/_streams.cpython-310.pyc,,
+anyio/_core/__pycache__/_subprocesses.cpython-310.pyc,,
+anyio/_core/__pycache__/_synchronization.cpython-310.pyc,,
+anyio/_core/__pycache__/_tasks.cpython-310.pyc,,
+anyio/_core/__pycache__/_testing.cpython-310.pyc,,
+anyio/_core/__pycache__/_typedattr.cpython-310.pyc,,
+anyio/_core/_asyncio_selector_thread.py,sha256=vTdZBWaxRgVcgUaRb5uBwQ_VGgY3qPKF7l91IJ5Mqzo,4773
+anyio/_core/_eventloop.py,sha256=t_tAwBFPjF8jrZGjlJ6bbYy6KA3bjsbZxV9mvh9t1i0,4695
+anyio/_core/_exceptions.py,sha256=bKPr2QbkYG7nIb425L5JePUie9bGc9XfkY0y4JKWvFM,2488
+anyio/_core/_fileio.py,sha256=DqnG_zvQFMqiIFaUeDRC1Ts3LT0FWHkWtGgm-684hvQ,20957
+anyio/_core/_resources.py,sha256=NbmU5O5UX3xEyACnkmYX28Fmwdl-f-ny0tHym26e0w0,435
+anyio/_core/_signals.py,sha256=vulT1M1xdLYtAR-eY5TamIgaf1WTlOwOrMGwswlTTr8,905
+anyio/_core/_sockets.py,sha256=vQ5GnSDLHjEhHhV2yvsdiPs5wmPxxb1kRsv3RM5lbQk,26951
+anyio/_core/_streams.py,sha256=OnaKgoDD-FcMSwLvkoAUGP51sG2ZdRvMpxt9q2w1gYA,1804
+anyio/_core/_subprocesses.py,sha256=WquR6sHrnaZofaeqnL8U4Yv___msVW_WqivleLHK4zI,7760
+anyio/_core/_synchronization.py,sha256=tct5FJFdgYjiEMtUeg5NGG15tf-2Qd7VaWuSgzS5dIU,20347
+anyio/_core/_tasks.py,sha256=pvVEX2Fw159sf0ypAPerukKsZgRRwvFFedVW52nR2Vk,4764
+anyio/_core/_testing.py,sha256=YUGwA5cgFFbUTv4WFd7cv_BSVr4ryTtPp8owQA3JdWE,2118
+anyio/_core/_typedattr.py,sha256=P4ozZikn3-DbpoYcvyghS_FOYAgbmUxeoU8-L_07pZM,2508
+anyio/abc/__init__.py,sha256=c2OQbTCS_fQowviMXanLPh8m29ccwkXmpDr7uyNZYOo,2652
+anyio/abc/__pycache__/__init__.cpython-310.pyc,,
+anyio/abc/__pycache__/_eventloop.cpython-310.pyc,,
+anyio/abc/__pycache__/_resources.cpython-310.pyc,,
+anyio/abc/__pycache__/_sockets.cpython-310.pyc,,
+anyio/abc/__pycache__/_streams.cpython-310.pyc,,
+anyio/abc/__pycache__/_subprocesses.cpython-310.pyc,,
+anyio/abc/__pycache__/_tasks.cpython-310.pyc,,
+anyio/abc/__pycache__/_testing.cpython-310.pyc,,
+anyio/abc/_eventloop.py,sha256=Wd_3C3hLm0ex5z_eHHWGqvLle2OKCSexJSZVnwQNGV4,9658
+anyio/abc/_resources.py,sha256=DrYvkNN1hH6Uvv5_5uKySvDsnknGVDe8FCKfko0VtN8,783
+anyio/abc/_sockets.py,sha256=KhWtJxan8jpBXKwPaFeQzI4iRXdFaOIn0HXtDZnaO7U,6262
+anyio/abc/_streams.py,sha256=GzST5Q2zQmxVzdrAqtbSyHNxkPlIC9AzeZJg_YyPAXw,6598
+anyio/abc/_subprocesses.py,sha256=cumAPJTktOQtw63IqG0lDpyZqu_l1EElvQHMiwJgL08,2067
+anyio/abc/_tasks.py,sha256=yJWbMwowvqjlAX4oJ3l9Is1w-zwynr2lX1Z02AWJqsY,3080
+anyio/abc/_testing.py,sha256=tBJUzkSfOXJw23fe8qSJ03kJlShOYjjaEyFB6k6MYT8,1821
+anyio/from_thread.py,sha256=dbi5TUH45_Sg_jZ8Vv1NJWVohe0WeQ_OaCvXIKveAGg,17478
+anyio/lowlevel.py,sha256=nkgmW--SdxGVp0cmLUYazjkigveRm5HY7-gW8Bpp9oY,4169
+anyio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/pytest_plugin.py,sha256=vjGhGRHD31OyMgJRFQrMvExhx3Ea8KbyDqYKmiSDdXA,6712
+anyio/streams/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/streams/__pycache__/__init__.cpython-310.pyc,,
+anyio/streams/__pycache__/buffered.cpython-310.pyc,,
+anyio/streams/__pycache__/file.cpython-310.pyc,,
+anyio/streams/__pycache__/memory.cpython-310.pyc,,
+anyio/streams/__pycache__/stapled.cpython-310.pyc,,
+anyio/streams/__pycache__/text.cpython-310.pyc,,
+anyio/streams/__pycache__/tls.cpython-310.pyc,,
+anyio/streams/buffered.py,sha256=UCldKC168YuLvT7n3HtNPnQ2iWAMSTYQWbZvzLwMwkM,4500
+anyio/streams/file.py,sha256=6uoTNb5KbMoj-6gS3_xrrL8uZN8Q4iIvOS1WtGyFfKw,4383
+anyio/streams/memory.py,sha256=j8AyOExK4-UPaon_Xbhwax25Vqs0DwFg3ZXc-EIiHjY,10550
+anyio/streams/stapled.py,sha256=U09pCrmOw9kkNhe6tKopsm1QIMT1lFTFvtb-A7SIe4k,4302
+anyio/streams/text.py,sha256=6x8w8xlfCZKTUWQoJiMPoMhSSJFUBRKgoBNSBtbd9yg,5094
+anyio/streams/tls.py,sha256=m3AE2LVSpoRHSIwSoSCupiOVL54EvOFoY3CcwTxcZfg,12742
+anyio/to_process.py,sha256=cR4n7TssbbJowE_9cWme49zaeuoBuMzqgZ6cBIs0YIs,9571
+anyio/to_thread.py,sha256=WM2JQ2MbVsd5D5CM08bQiTwzZIvpsGjfH1Fy247KoDQ,2396

vllm/lib/python3.10/site-packages/anyio-4.7.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vllm/lib/python3.10/site-packages/anyio-4.7.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+anyio = anyio.pytest_plugin

vllm/lib/python3.10/site-packages/anyio-4.7.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+anyio

vllm/lib/python3.10/site-packages/opencensus/__init__.py

@@ -0,0 +1 @@
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)

vllm/lib/python3.10/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)

vllm/lib/python3.10/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.

vllm/lib/python3.10/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

vllm/lib/python3.10/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']

vllm/lib/python3.10/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

vllm/lib/python3.10/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

vllm/lib/python3.10/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

vllm/lib/python3.10/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

vllm/lib/python3.10/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

vllm/lib/python3.10/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)

vllm/lib/python3.10/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()

vllm/lib/python3.10/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

vllm/lib/python3.10/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.

vllm/lib/python3.10/site-packages/opencensus/trace/propagation/b3_format.py

@@ -0,0 +1,117 @@
+# 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.trace.span_context import INVALID_SPAN_ID, SpanContext
+from opencensus.trace.trace_options import TraceOptions
+
+_STATE_HEADER_KEY = 'b3'
+_TRACE_ID_KEY = 'x-b3-traceid'
+_SPAN_ID_KEY = 'x-b3-spanid'
+_SAMPLED_KEY = 'x-b3-sampled'
+
+
+class B3FormatPropagator(object):
+    """Propagator for the B3 HTTP header format.
+
+    See: https://github.com/openzipkin/b3-propagation
+    """
+
+    def from_headers(self, headers):
+        """Generate a SpanContext object from B3 propagation headers.
+
+        :type headers: dict
+        :param headers: HTTP request headers.
+
+        :rtype: :class:`~opencensus.trace.span_context.SpanContext`
+        :returns: SpanContext generated from B3 propagation headers.
+        """
+        if headers is None:
+            return SpanContext(from_header=False)
+
+        trace_id, span_id, sampled = None, None, None
+
+        state = headers.get(_STATE_HEADER_KEY)
+        if state:
+            fields = state.split('-', 4)
+
+            if len(fields) == 1:
+                sampled = fields[0]
+            elif len(fields) == 2:
+                trace_id, span_id = fields
+            elif len(fields) == 3:
+                trace_id, span_id, sampled = fields
+            elif len(fields) == 4:
+                trace_id, span_id, sampled, _parent_span_id = fields
+            else:
+                return SpanContext(from_header=False)
+        else:
+            trace_id = headers.get(_TRACE_ID_KEY)
+            span_id = headers.get(_SPAN_ID_KEY)
+            sampled = headers.get(_SAMPLED_KEY)
+
+        if sampled is not None:
+            # The specification encodes an enabled tracing decision as "1".
+            # In the wild pre-standard implementations might still send "true".
+            # "d" is set in the single header case when debugging is enabled.
+            sampled = sampled.lower() in ('1', 'd', 'true')
+        else:
+            # If there's no incoming sampling decision, it was deferred to us.
+            # Even though we set it to False here, we might still sample
+            # depending on the tracer configuration.
+            sampled = False
+
+        trace_options = TraceOptions()
+        trace_options.set_enabled(sampled)
+
+        # TraceId and SpanId headers both have to exist
+        if not trace_id or not span_id:
+            return SpanContext(trace_options=trace_options)
+
+        # Convert 64-bit trace ids to 128-bit
+        if len(trace_id) == 16:
+            trace_id = '0'*16 + trace_id
+
+        span_context = SpanContext(
+            trace_id=trace_id,
+            span_id=span_id,
+            trace_options=trace_options,
+            from_header=True
+        )
+
+        return span_context
+
+    def to_headers(self, span_context):
+        """Convert a SpanContext object to B3 propagation headers.
+
+        :type span_context:
+            :class:`~opencensus.trace.span_context.SpanContext`
+        :param span_context: SpanContext object.
+
+        :rtype: dict
+        :returns: B3 propagation headers.
+        """
+
+        if not span_context.span_id:
+            span_id = INVALID_SPAN_ID
+        else:
+            span_id = span_context.span_id
+
+        sampled = span_context.trace_options.enabled
+
+        return {
+            _TRACE_ID_KEY: span_context.trace_id,
+            _SPAN_ID_KEY: span_id,
+            _SAMPLED_KEY: '1' if sampled else '0'
+        }

vllm/lib/python3.10/site-packages/opencensus/trace/propagation/binary_format.py

@@ -0,0 +1,168 @@
+# 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 binascii
+import collections
+import logging
+import struct
+
+from opencensus.trace import span_context as span_context_module
+from opencensus.trace.trace_options import TraceOptions
+
+# Used for decoding hex bytes to hex string.
+UTF8 = 'utf-8'
+
+VERSION_ID = 0
+TRACE_ID_FIELD_ID = 0
+SPAN_ID_FIELD_ID = 1
+TRACE_OPTION_FIELD_ID = 2
+
+# Sizes are number of bytes.
+ID_SIZE = 1
+TRACE_ID_SIZE = 16
+SPAN_ID_SIZE = 8
+TRACE_OPTION_SIZE = 1
+
+FORMAT_LENGTH = 4 * ID_SIZE + TRACE_ID_SIZE + SPAN_ID_SIZE + TRACE_OPTION_SIZE
+
+# See: https://docs.python.org/3/library/struct.html#format-characters
+BIG_ENDIAN = '>'
+CHAR_ARRAY_FORMAT = 's'
+UNSIGNED_CHAR = 'B'
+UNSIGNED_LONG_LONG = 'Q'
+
+# Adding big endian indicator at the beginning to avoid auto padding. This is
+# for ensuring the length of binary is not changed when propagating.
+BINARY_FORMAT = '{big_endian}{version_id}' \
+    '{trace_id_field_id}{trace_id}' \
+    '{span_id_field_id}{span_id}' \
+    '{trace_option_field_id}{trace_option}'\
+    .format(
+        big_endian=BIG_ENDIAN,
+        version_id=UNSIGNED_CHAR,
+        trace_id_field_id=UNSIGNED_CHAR,
+        trace_id='{}{}'.format(TRACE_ID_SIZE, CHAR_ARRAY_FORMAT),
+        span_id_field_id=UNSIGNED_CHAR,
+        span_id='{}{}'.format(SPAN_ID_SIZE, CHAR_ARRAY_FORMAT),
+        trace_option_field_id=UNSIGNED_CHAR,
+        trace_option=UNSIGNED_CHAR)
+
+Header = collections.namedtuple(
+    'Header',
+    'version_id '
+    'trace_id_field_id '
+    'trace_id '
+    'span_id_field_id '
+    'span_id '
+    'trace_option_field_id '
+    'trace_option')
+
+
+class BinaryFormatPropagator(object):
+    """This propagator contains the method for serializing and deserializing
+    SpanContext using a binary format.
+
+    See: https://github.com/census-instrumentation/opencensus-specs/blob/
+         master/encodings/BinaryEncoding.md
+
+    Example:
+        [SpanContext]
+            trace_id: hex string with length 32.
+                e.g. 'a0b72ca15c1a4bd18962d0ac59dc90b9'
+            span_id: hex string with length 16.
+                e.g. 'a0b72ca15c1a4bd1'
+            enabled (trace option): bool.
+                e.g. True
+        [Binary Format]
+            trace_id: Bytes with length 16.
+                e.g. b'\xa0\xb7,\xa1\\\x1aK\xd1\x89b\xd0\xacY\xdc\x90\xb9'
+            span_id: Bytes with length 8.
+                e.g. b'\x00\xf0g\xaa\x0b\xa9\x02\xb7'
+            trace_option: Byte with length 1.
+                e.g. b'\x01'
+    """
+    def from_header(self, binary):
+        """Generate a SpanContext object using the trace context header.
+        The value of enabled parsed from header is int. Need to convert to
+        bool.
+
+        :type binary: bytes
+        :param binary: Trace context header which was extracted from the
+                       request headers.
+
+        :rtype: :class:`~opencensus.trace.span_context.SpanContext`
+        :returns: SpanContext generated from the trace context header.
+        """
+        # If no binary provided, generate a new SpanContext
+        if binary is None:
+            return span_context_module.SpanContext(from_header=False)
+
+        # If cannot parse, return a new SpanContext and ignore the context
+        # from binary.
+        try:
+            data = Header._make(struct.unpack(BINARY_FORMAT, binary))
+        except struct.error:
+            logging.warning(
+                'Cannot parse the incoming binary data {}, '
+                'wrong format. Total bytes length should be {}.'.format(
+                    binary, FORMAT_LENGTH
+                )
+            )
+            return span_context_module.SpanContext(from_header=False)
+
+        # data.trace_id is in bytes with length 16, hexlify it to hex bytes
+        # with length 32, then decode it to hex string using utf-8.
+        trace_id = str(binascii.hexlify(data.trace_id).decode(UTF8))
+        span_id = str(binascii.hexlify(data.span_id).decode(UTF8))
+        trace_options = TraceOptions(data.trace_option)
+
+        span_context = span_context_module.SpanContext(
+                trace_id=trace_id,
+                span_id=span_id,
+                trace_options=trace_options,
+                from_header=True)
+
+        return span_context
+
+    def to_header(self, span_context):
+        """Convert a SpanContext object to header in binary format.
+
+        :type span_context:
+            :class:`~opencensus.trace.span_context.SpanContext`
+        :param span_context: SpanContext object.
+
+        :rtype: bytes
+        :returns: A trace context header in binary format.
+        """
+        trace_id = span_context.trace_id
+        span_id = span_context.span_id
+        trace_options = int(span_context.trace_options.trace_options_byte)
+
+        # If there is no span_id in this context, set it to 0, which is
+        # considered invalid and won't be set as the downstream parent span_id.
+        if span_id is None:
+            span_id = span_context_module.INVALID_SPAN_ID
+
+        # Convert trace_id to bytes with length 16, treat span_id as 64 bit
+        # integer which is unsigned long long type and convert it to bytes with
+        # length 8, trace_option is integer with length 1.
+        return struct.pack(
+            BINARY_FORMAT,
+            VERSION_ID,
+            TRACE_ID_FIELD_ID,
+            binascii.unhexlify(trace_id),
+            SPAN_ID_FIELD_ID,
+            binascii.unhexlify(span_id),
+            TRACE_OPTION_FIELD_ID,
+            trace_options)

vllm/lib/python3.10/site-packages/opencensus/trace/propagation/google_cloud_format.py

@@ -0,0 +1,128 @@
+# 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 logging
+import re
+
+from opencensus.trace.span_context import SpanContext
+from opencensus.trace.trace_options import TraceOptions
+
+_TRACE_CONTEXT_HEADER_NAME = 'X-Cloud-Trace-Context'
+_TRACE_CONTEXT_HEADER_FORMAT = r'([0-9a-f]{32})(\/([\d]{0,20}))?(;o=(\d+))?'
+_TRACE_CONTEXT_HEADER_RE = re.compile(_TRACE_CONTEXT_HEADER_FORMAT)
+_TRACE_ID_DELIMETER = '/'
+_SPAN_ID_DELIMETER = ';'
+
+
+class GoogleCloudFormatPropagator(object):
+    """This class is for converting the trace header in google cloud format
+    and generate a SpanContext, or converting a SpanContext to a google cloud
+    format header. Later we will add implementation for supporting other
+    format like binary format and zipkin, opencensus format.
+    """
+    def from_header(self, header):
+        """Generate a SpanContext object using the trace context header.
+        The value of enabled parsed from header is int. Need to convert to
+        bool.
+
+        :type header: str
+        :param header: Trace context header which was extracted from the HTTP
+                       request headers.
+
+        :rtype: :class:`~opencensus.trace.span_context.SpanContext`
+        :returns: SpanContext generated from the trace context header.
+        """
+        if header is None:
+            return SpanContext()
+
+        try:
+            match = re.search(_TRACE_CONTEXT_HEADER_RE, header)
+        except TypeError:
+            logging.warning(
+                'Header should be str, got %s. Cannot parse the header.',
+                header.__class__.__name__)
+            raise
+
+        if match:
+            trace_id = match.group(1)
+            span_id = match.group(3)
+            trace_options = match.group(5)
+
+            if trace_options is None:
+                trace_options = 1
+
+            if span_id:
+                span_id = '{:016x}'.format(int(span_id))
+
+            span_context = SpanContext(
+                trace_id=trace_id,
+                span_id=span_id,
+                trace_options=TraceOptions(trace_options),
+                from_header=True)
+            return span_context
+        else:
+            logging.warning(
+                'Cannot parse the header %s, generate a new context instead.',
+                header)
+            return SpanContext()
+
+    def from_headers(self, headers):
+        """Generate a SpanContext object using the trace context header.
+
+        :type headers: dict
+        :param headers: HTTP request headers.
+
+        :rtype: :class:`~opencensus.trace.span_context.SpanContext`
+        :returns: SpanContext generated from the trace context header.
+        """
+        if headers is None:
+            return SpanContext()
+        header = headers.get(_TRACE_CONTEXT_HEADER_NAME)
+        if header is None:
+            return SpanContext()
+        return self.from_header(header)
+
+    def to_header(self, span_context):
+        """Convert a SpanContext object to header string.
+
+        :type span_context:
+            :class:`~opencensus.trace.span_context.SpanContext`
+        :param span_context: SpanContext object.
+
+        :rtype: str
+        :returns: A trace context header string in google cloud format.
+        """
+        trace_id = span_context.trace_id
+        span_id = span_context.span_id
+        trace_options = span_context.trace_options.trace_options_byte
+
+        header = '{}/{};o={}'.format(
+            trace_id,
+            int(span_id, 16),
+            int(trace_options))
+        return header
+
+    def to_headers(self, span_context):
+        """Convert a SpanContext object to HTTP request headers.
+
+        :type span_context:
+            :class:`~opencensus.trace.span_context.SpanContext`
+        :param span_context: SpanContext object.
+
+        :rtype: dict
+        :returns: Trace context headers in google cloud format.
+        """
+        return {
+            _TRACE_CONTEXT_HEADER_NAME: self.to_header(span_context),
+        }

vllm/lib/python3.10/site-packages/opencensus/trace/propagation/text_format.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.
+
+from opencensus.trace.span_context import SpanContext
+from opencensus.trace.trace_options import TraceOptions
+
+_OPENCENSUS_TRACE_PREFIX = 'opencensus-trace'
+_TRACE_ID_KEY = '{}-traceid'.format(_OPENCENSUS_TRACE_PREFIX)
+_SPAN_ID_KEY = '{}-spanid'.format(_OPENCENSUS_TRACE_PREFIX)
+_TRACE_OPTIONS_KEY = '{}-traceoptions'.format(_OPENCENSUS_TRACE_PREFIX)
+
+DEFAULT_TRACE_OPTIONS = '1'
+
+
+class TextFormatPropagator(object):
+    """This class provides the basic utilities for extracting the trace
+    information from a carrier which is a dict to form a SpanContext. And
+    generating a dict using the provided SpanContext.
+    """
+    def from_carrier(self, carrier):
+        """Generate a SpanContext object using the information in the carrier.
+
+        :type carrier: dict
+        :param carrier: The carrier which has the trace_id, span_id, options
+                        information for creating a SpanContext.
+
+        :rtype: :class:`~opencensus.trace.span_context.SpanContext`
+        :returns: SpanContext generated from the carrier.
+        """
+        trace_id = None
+        span_id = None
+        trace_options = None
+
+        for key in carrier:
+            key = key.lower()
+            if key == _TRACE_ID_KEY:
+                trace_id = carrier[key]
+            if key == _SPAN_ID_KEY:
+                span_id = carrier[key]
+            if key == _TRACE_OPTIONS_KEY:
+                trace_options = bool(carrier[key])
+
+        if trace_options is None:
+            trace_options = DEFAULT_TRACE_OPTIONS
+
+        return SpanContext(
+            trace_id=trace_id,
+            span_id=span_id,
+            trace_options=TraceOptions(trace_options),
+            from_header=True)
+
+    def to_carrier(self, span_context, carrier):
+        """Inject the SpanContext fields to carrier dict.
+
+        :type span_context:
+            :class:`~opencensus.trace.span_context.SpanContext`
+        :param span_context: SpanContext object.
+
+        :type carrier: dict
+        :param carrier: The carrier which holds the trace_id, span_id, options
+                        information from a SpanContext.
+
+        :rtype: dict
+        :returns: The carrier which holds the span context information.
+        """
+        carrier[_TRACE_ID_KEY] = str(span_context.trace_id)
+
+        if span_context.span_id is not None:
+            carrier[_SPAN_ID_KEY] = str(span_context.span_id)
+
+        carrier[_TRACE_OPTIONS_KEY] = str(
+            span_context.trace_options.trace_options_byte)
+
+        return carrier

vllm/lib/python3.10/site-packages/opencensus/trace/propagation/trace_context_http_header_format.py

@@ -0,0 +1,115 @@
+# 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 re
+
+from opencensus.trace.propagation.tracestate_string_format import (
+    TracestateStringFormatter,
+)
+from opencensus.trace.span_context import SpanContext
+from opencensus.trace.trace_options import TraceOptions
+
+_TRACEPARENT_HEADER_NAME = 'traceparent'
+_TRACESTATE_HEADER_NAME = 'tracestate'
+_TRACEPARENT_HEADER_FORMAT = \
+    '^[ \t]*([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})' + \
+    '(-.*)?[ \t]*$'
+_TRACEPARENT_HEADER_FORMAT_RE = re.compile(_TRACEPARENT_HEADER_FORMAT)
+
+
+class TraceContextPropagator(object):
+    """Propagator for processing the trace context HTTP header format."""
+
+    def from_headers(self, headers):
+        """Generate a SpanContext object using the W3C Distributed Tracing headers.
+
+        :type headers: dict
+        :param headers: HTTP request headers.
+
+        :rtype: :class:`~opencensus.trace.span_context.SpanContext`
+        :returns: SpanContext generated from the trace context header.
+        """
+        if headers is None:
+            return SpanContext()
+
+        header = headers.get(_TRACEPARENT_HEADER_NAME)
+        if header is None:
+            return SpanContext()
+
+        match = re.search(_TRACEPARENT_HEADER_FORMAT_RE, header)
+        if not match:
+            return SpanContext()
+
+        version = match.group(1)
+        trace_id = match.group(2)
+        span_id = match.group(3)
+        trace_options = match.group(4)
+
+        if trace_id == '0' * 32 or span_id == '0' * 16:
+            return SpanContext()
+
+        if version == '00':
+            if match.group(5):
+                return SpanContext()
+        if version == 'ff':
+            return SpanContext()
+
+        span_context = SpanContext(
+            trace_id=trace_id,
+            span_id=span_id,
+            trace_options=TraceOptions(trace_options),
+            from_header=True)
+
+        header = headers.get(_TRACESTATE_HEADER_NAME)
+        if header is None:
+            return span_context
+        try:
+            tracestate = TracestateStringFormatter().from_string(header)
+            if tracestate.is_valid():
+                span_context.tracestate = \
+                    TracestateStringFormatter().from_string(header)
+        except ValueError:
+            pass
+        return span_context
+
+    def to_headers(self, span_context):
+        """Convert a SpanContext object to W3C Distributed Tracing headers,
+        using version 0.
+
+        :type span_context:
+            :class:`~opencensus.trace.span_context.SpanContext`
+        :param span_context: SpanContext object.
+
+        :rtype: dict
+        :returns: W3C Distributed Tracing headers.
+        """
+        trace_id = span_context.trace_id
+        span_id = span_context.span_id
+        trace_options = span_context.trace_options.enabled
+
+        # Convert the trace options
+        trace_options = '01' if trace_options else '00'
+
+        headers = {
+            _TRACEPARENT_HEADER_NAME: '00-{}-{}-{}'.format(
+                trace_id,
+                span_id,
+                trace_options
+            ),
+        }
+        tracestate = span_context.tracestate
+        if tracestate:
+            headers[_TRACESTATE_HEADER_NAME] = \
+                TracestateStringFormatter().to_string(tracestate)
+        return headers

vllm/lib/python3.10/site-packages/opencensus/trace/propagation/tracestate_string_format.py

@@ -0,0 +1,43 @@
+# 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.
+
+import re
+
+from opencensus.trace.tracestate import _KEY_FORMAT, _VALUE_FORMAT, Tracestate
+
+_DELIMITER_FORMAT = '[ \t]*,[ \t]*'
+_MEMBER_FORMAT = '(%s)(=)(%s)' % (_KEY_FORMAT, _VALUE_FORMAT)
+
+_DELIMITER_FORMAT_RE = re.compile(_DELIMITER_FORMAT)
+_MEMBER_FORMAT_RE = re.compile(_MEMBER_FORMAT)
+
+
+class TracestateStringFormatter(object):
+    def from_string(self, string):
+        tracestate = Tracestate()
+        for member in re.split(_DELIMITER_FORMAT_RE, string):
+            match = _MEMBER_FORMAT_RE.match(member)
+            if not match:
+                raise ValueError('illegal key-value format %r' % (member))
+            key, eq, value = match.groups()
+            if key in tracestate:
+                raise ValueError('conflict key {!r}'.format(key))
+            tracestate[key] = value
+        return tracestate
+
+    def to_string(self, tracestate):
+        return ','.join(map(
+            lambda key: key + '=' + tracestate[key],
+            tracestate
+        ))

vllm/lib/python3.10/site-packages/opencensus/trace/samplers/__init__.py

@@ -0,0 +1,94 @@
+# 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.
+
+
+DEFAULT_SAMPLING_RATE = 1e-4
+
+
+class Sampler(object):
+    """Base class for opencensus trace request samplers.
+
+    Subclasses must override :meth:`should_sample`.
+    """
+
+    def should_sample(self, span_context):
+        """Whether to sample this request.
+
+        :type span_context: :class:`opencensus.trace.span_context.SpanContext`
+        :param span_context: The span context.
+
+        :rtype: bool
+        :returns: Whether to sample the request according to the context.
+        """
+        raise NotImplementedError
+
+
+class AlwaysOnSampler(Sampler):
+    """Sampler that samples every request, regardless of trace options."""
+
+    def should_sample(self, span_context):
+        return True
+
+
+class AlwaysOffSampler(Sampler):
+    """Sampler that doesn't sample any request, regardless of trace options."""
+
+    def should_sample(self, span_context):
+        return False
+
+
+class ProbabilitySampler(Sampler):
+    """Sample a request at a fixed rate.
+
+    :type rate: float
+    :param rate: The rate of sampling.
+    """
+    def __init__(self, rate=None):
+        if rate is None:
+            rate = DEFAULT_SAMPLING_RATE
+
+        if not 0 <= rate <= 1:
+            raise ValueError('Rate must between 0 and 1.')
+
+        self.rate = rate
+
+    def should_sample(self, span_context):
+        """Make the sampling decision based on the lower 8 bytes of the trace
+        ID. If the value is less than the bound, return True, else False.
+
+        :type span_context: :class:`opencensus.trace.span_context.SpanContext`
+        :param span_context: The span context.
+
+        :rtype: bool
+        :returns: Whether to sample the request according to the context.
+        """
+        if span_context.trace_options.get_enabled():
+            return True
+
+        lower_long = get_lower_long_from_trace_id(span_context.trace_id)
+        bound = self.rate * 0xffffffffffffffff
+        return lower_long <= bound
+
+
+def get_lower_long_from_trace_id(trace_id):
+    """Returns the lower 8 bytes of the trace ID as a long value, assuming
+    little endian order.
+
+    :rtype: long
+    :returns: Lower 8 bytes of trace ID
+    """
+    lower_bytes = trace_id[16:]
+    lower_long = int(lower_bytes, 16)
+
+    return lower_long

vllm/lib/python3.10/site-packages/opencensus/trace/span_context.py

@@ -0,0 +1,168 @@
+# 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.
+
+"""SpanContext encapsulates the current context within the request's trace."""
+
+import six
+
+import logging
+import random
+import re
+
+from opencensus.trace import trace_options as trace_options_module
+
+_INVALID_TRACE_ID = '0' * 32
+INVALID_SPAN_ID = '0' * 16
+
+TRACE_ID_PATTERN = re.compile('[0-9a-f]{32}?')
+SPAN_ID_PATTERN = re.compile('[0-9a-f]{16}?')
+
+# Default options, don't force sampling
+DEFAULT_OPTIONS = '0'
+
+
+class SpanContext(object):
+    """SpanContext includes 3 fields: traceId, spanId, and an trace_options flag
+    which indicates whether or not the request is being traced. It contains the
+    current context to be propagated to the child spans.
+
+    :type trace_id: str
+    :param trace_id: (Optional) Trace_id is a 32 digits uuid for the trace.
+                     If not given, will generate one automatically.
+
+    :type span_id: str
+    :param span_id: (Optional) Identifier for the span, unique within a trace.
+
+    :type trace_options: :class: `~opencensus.trace.trace_options.TraceOptions`
+    :param trace_options: (Optional) TraceOptions indicates 8 trace options.
+
+    :type from_header: bool
+    :param from_header: (Optional) Indicates whether the trace context is
+                        generated from request header.
+    """
+    def __init__(
+            self,
+            trace_id=None,
+            span_id=None,
+            trace_options=None,
+            tracestate=None,
+            from_header=False):
+        if trace_id is None:
+            trace_id = generate_trace_id()
+
+        if trace_options is None:
+            trace_options = trace_options_module.TraceOptions(DEFAULT_OPTIONS)
+
+        self.from_header = from_header
+        self.trace_id = self._check_trace_id(trace_id)
+        self.span_id = self._check_span_id(span_id)
+        self.trace_options = trace_options
+        self.tracestate = tracestate
+
+    def __repr__(self):
+        """Returns a string form of the SpanContext.
+
+        :rtype: str
+        :returns: String form of the SpanContext.
+        """
+        fmt = '{}(trace_id={}, span_id={}, trace_options={}, tracestate={})'
+        return fmt.format(
+            type(self).__name__,
+            self.trace_id,
+            self.span_id,
+            self.trace_options,
+            self.tracestate,
+        )
+
+    def _check_span_id(self, span_id):
+        """Check the format of the span_id to ensure it is 16-character hex
+        value representing a 64-bit number. If span_id is invalid, logs a
+        warning message and returns None
+
+        :type span_id: str
+        :param span_id: Identifier for the span, unique within a span.
+
+        :rtype: str
+        :returns: Span_id for the current span.
+        """
+        if span_id is None:
+            return None
+        assert isinstance(span_id, six.string_types)
+
+        if span_id is INVALID_SPAN_ID:
+            logging.warning(
+                'Span_id %s is invalid (cannot be all zero)', span_id)
+            self.from_header = False
+            return None
+
+        match = SPAN_ID_PATTERN.match(span_id)
+
+        if match:
+            return span_id
+        else:
+            logging.warning(
+                'Span_id %s does not the match the '
+                'required format', span_id)
+            self.from_header = False
+            return None
+
+    def _check_trace_id(self, trace_id):
+        """Check the format of the trace_id to ensure it is 32-character hex
+        value representing a 128-bit number. If trace_id is invalid, returns a
+        randomly generated trace id
+
+        :type trace_id: str
+        :param trace_id:
+
+        :rtype: str
+        :returns: Trace_id for the current context.
+        """
+        assert isinstance(trace_id, six.string_types)
+
+        if trace_id is _INVALID_TRACE_ID:
+            logging.warning(
+                'Trace_id %s is invalid (cannot be all zero), '
+                'generating a new one.', trace_id)
+            self.from_header = False
+            return generate_trace_id()
+
+        match = TRACE_ID_PATTERN.match(trace_id)
+
+        if match:
+            return trace_id
+        else:
+            logging.warning(
+                'Trace_id %s does not the match the required format,'
+                'generating a new one instead.', trace_id)
+            self.from_header = False
+            return generate_trace_id()
+
+
+def generate_span_id():
+    """Return the random generated span ID for a span. Must be a 16 character
+    hexadecimal encoded string
+
+    :rtype: str
+    :returns: 16 digit randomly generated hex trace id.
+    """
+    return '{:016x}'.format(random.getrandbits(64))
+
+
+def generate_trace_id():
+    """Generate a random 32 char hex trace_id.
+
+    :rtype: str
+    :returns: 32 digit randomly generated hex trace id.
+    """
+    return '{:032x}'.format(random.getrandbits(128))

vllm/lib/python3.10/site-packages/opencensus/trace/stack_trace.py

@@ -0,0 +1,189 @@
+# 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 hashlib
+import os
+import random
+import traceback
+
+from opencensus.common.utils import get_truncatable_str
+
+MAX_FRAMES = 128
+
+BUILD_ID = os.environ.get('BUILD_ID', 'unknown')
+SOURCE_VERSION = os.environ.get('SOURCE_VERSION', 'unknown')
+
+
+class StackFrame(object):
+    """Represents a single stack frame in a stack trace.
+
+    :type func_name: str
+    :param func_name: The fully-qualified name that uniquely identifies the
+                      function or method that is active in this frame (up to
+                      1024 bytes).
+
+    :type original_func_name: str
+    :param original_func_name: An un-mangled function name, if functionName is
+                               mangled. The name can be fully-qualified
+                               (up to 1024 bytes).
+
+    :type file_name: str
+    :param file_name: The name of the source file where the function call
+                      appears (up to 256 bytes).
+
+    :type line_num: int
+    :param line_num: The line number in fileName where the function call
+                     appears.
+
+    :type col_num: int
+    :param col_num: The column number where the function call appears, if
+                    available. This is important in JavaScript because of its
+                    anonymous functions.
+
+    :type load_module: str
+    :param load_module: For example: main binary, kernel modules, and dynamic
+                        libraries such as libc.so, sharedlib.so
+                        (up to 256 bytes).
+
+    :type build_id: str
+    :param build_id: A unique identifier for the module, usually a hash of its
+                    contents (up to 128 bytes).
+
+
+    :type source_version: str
+    :param source_version: The version of the deployed source code
+                           (up to 128 bytes).
+    """
+    def __init__(self,
+                 func_name,
+                 original_func_name,
+                 file_name,
+                 line_num,
+                 col_num,
+                 load_module,
+                 build_id,
+                 source_version):
+        self.func_name = func_name
+        self.original_func_name = original_func_name
+        self.file_name = file_name
+        self.line_num = line_num
+        self.col_num = col_num
+        self.load_module = load_module
+        self.build_id = build_id
+        self.source_version = source_version
+
+    def format_stack_frame_json(self):
+        """Convert StackFrame object to json format."""
+        stack_frame_json = {}
+        stack_frame_json['function_name'] = get_truncatable_str(
+            self.func_name)
+        stack_frame_json['original_function_name'] = get_truncatable_str(
+            self.original_func_name)
+        stack_frame_json['file_name'] = get_truncatable_str(self.file_name)
+        stack_frame_json['line_number'] = self.line_num
+        stack_frame_json['column_number'] = self.col_num
+        stack_frame_json['load_module'] = {
+            'module': get_truncatable_str(self.load_module),
+            'build_id': get_truncatable_str(self.build_id),
+        }
+        stack_frame_json['source_version'] = get_truncatable_str(
+            self.source_version)
+
+        return stack_frame_json
+
+
+class StackTrace(object):
+    """A call stack appearing in a trace.
+
+    :type stack_frames: list
+    :param stack_frames: Stack frames in this stack trace. A maximum of 128
+                         frames are allowed.
+
+    :type stack_trace_hash_id: str
+    :param stack_trace_hash_id: The hash ID is used to conserve network
+                                bandwidth for duplicate stack traces within a
+                                single trace.
+    """
+    def __init__(self, stack_frames=None, stack_trace_hash_id=None):
+        if stack_frames is None:
+            stack_frames = []
+        if len(stack_frames) > MAX_FRAMES:
+            self.dropped_frames_count = len(stack_frames) - MAX_FRAMES
+            stack_frames = stack_frames[-MAX_FRAMES:]
+        else:
+            self.dropped_frames_count = 0
+
+        if stack_trace_hash_id is None:
+            stack_trace_hash_id = generate_hash_id()
+
+        self.stack_frames = stack_frames
+        self.stack_trace_hash_id = stack_trace_hash_id
+
+    @classmethod
+    def from_traceback(cls, tb):
+        """Initializes a StackTrace from a python traceback instance"""
+        stack_trace = cls(
+            stack_trace_hash_id=generate_hash_id_from_traceback(tb)
+        )
+        # use the add_stack_frame so that json formatting is applied
+        for tb_frame_info in traceback.extract_tb(tb):
+            filename, line_num, fn_name, _ = tb_frame_info
+            stack_trace.add_stack_frame(
+                StackFrame(
+                    func_name=fn_name,
+                    original_func_name=fn_name,
+                    file_name=filename,
+                    line_num=line_num,
+                    col_num=0,  # I don't think this is available in python
+                    load_module=filename,
+                    build_id=BUILD_ID,
+                    source_version=SOURCE_VERSION
+                )
+            )
+        return stack_trace
+
+    def add_stack_frame(self, stack_frame):
+        """Add StackFrame to frames list."""
+        if len(self.stack_frames) >= MAX_FRAMES:
+            self.dropped_frames_count += 1
+        else:
+            self.stack_frames.append(stack_frame.format_stack_frame_json())
+
+    def format_stack_trace_json(self):
+        """Convert a StackTrace object to json format."""
+        stack_trace_json = {}
+
+        if self.stack_frames:
+            stack_trace_json['stack_frames'] = {
+                'frame': self.stack_frames,
+                'dropped_frames_count': self.dropped_frames_count
+            }
+
+        stack_trace_json['stack_trace_hash_id'] = self.stack_trace_hash_id
+
+        return stack_trace_json
+
+
+def generate_hash_id():
+    """Generate a hash id."""
+    return random.getrandbits(64)
+
+
+def generate_hash_id_from_traceback(tb):
+    m = hashlib.md5()  # nosec
+    for tb_line in traceback.format_tb(tb):
+        m.update(tb_line.encode('utf-8'))
+    # truncate the hash for easier compatibility with StackDriver,
+    # should still be unique enough to avoid collisions
+    return int(m.hexdigest()[:12], 16)

vllm/lib/python3.10/site-packages/opencensus/trace/status.py

@@ -0,0 +1,84 @@
+# 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
+
+
+class Status(object):
+    """The Status type defines a logical error model that is suitable for
+    different programming environments, including REST APIs and RPC APIs.
+    It is used by gRPC.
+
+    :type code: int
+    :param code: An enum value of :class: `~google.rpc.Code`.
+
+    :type message: str
+    :param message: A developer-facing error message, should be in English.
+
+    :type details: list
+    :param details: A list of messages that carry the error details.
+                    There is a common set of message types for APIs to use.
+                    e.g. [
+                            {
+                                "@type": string,
+                                field1: ...,
+                                ...
+                            },
+                         ]
+                    See: https://cloud.google.com/trace/docs/reference/v2/
+                         rest/v2/Status#FIELDS.details
+    """
+    def __init__(self, code, message=None, details=None):
+        self.code = code
+        self.message = message
+        self.details = details
+
+    @property
+    def canonical_code(self):
+        return self.code
+
+    @property
+    def description(self):
+        return self.message
+
+    @property
+    def is_ok(self):
+        return self.canonical_code == code_pb2.OK
+
+    def format_status_json(self):
+        """Convert a Status object to json format."""
+        status_json = {}
+
+        status_json['code'] = self.canonical_code
+
+        if self.description is not None:
+            status_json['message'] = self.description
+
+        if self.details is not None:
+            status_json['details'] = self.details
+
+        return status_json
+
+    @classmethod
+    def from_exception(cls, exc):
+        return cls(
+            code=code_pb2.UNKNOWN,
+            message=str(exc)
+        )
+
+    @classmethod
+    def as_ok(cls):
+        return cls(
+            code=code_pb2.OK,
+        )

vllm/lib/python3.10/site-packages/opencensus/trace/trace_options.py

@@ -0,0 +1,78 @@
+# 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 logging
+
+# Enabled field is the least significant bit of trace options.
+_ENABLED_BITMASK = 1 << 0
+
+# Default trace options
+DEFAULT = '1'
+
+
+class TraceOptions(object):
+    """A class that represents global trace options.
+
+    :type trace_options_byte: str
+    :param trace_options_byte: 1 byte bitmap for trace options.
+    """
+
+    def __init__(self, trace_options_byte=None):
+        if trace_options_byte is None:
+            trace_options_byte = DEFAULT
+
+        self.trace_options_byte = self.check_trace_options(trace_options_byte)
+        self.enabled = self.get_enabled()
+
+    def check_trace_options(self, trace_options_byte):
+        trace_options_int = int(trace_options_byte)
+
+        if trace_options_int < 0 or trace_options_int > 255:
+            logging.warning("Trace options invalid, should be 1 byte.")
+            trace_options_byte = DEFAULT
+
+        return trace_options_byte
+
+    def __repr__(self):
+        fmt = '{}(enabled={})'
+        return fmt.format(
+            type(self).__name__,
+            self.get_enabled(),
+        )
+
+    def get_enabled(self):
+        """Get the last bit from the trace options which is the enabled field.
+
+        :type trace_options: byte
+        :param trace_options: 1 byte field which indicates 8 trace options,
+                              currently only have the enabled option. 1 means
+                              enabled, 0 means not enabled.
+
+        :rtype: bool
+        :returns: Enabled tracing or not.
+        """
+        enabled = bool(int(self.trace_options_byte) & _ENABLED_BITMASK)
+
+        return enabled
+
+    def set_enabled(self, enabled):
+        """Update the last bit of the trace options byte str.
+
+        :type enabled: bool
+        :param enabled: Whether enable tracing in this span context or not.
+        """
+        enabled_bit = '1' if enabled else '0'
+        self.trace_options_byte = str(
+            self.trace_options_byte)[:-1] + enabled_bit
+        self.enabled = self.get_enabled()

vllm/lib/python3.10/site-packages/opencensus/trace/tracer.py

@@ -0,0 +1,144 @@
+# 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 execution_context, print_exporter, samplers
+from opencensus.trace.propagation import trace_context_http_header_format
+from opencensus.trace.span_context import SpanContext
+from opencensus.trace.tracers import context_tracer, noop_tracer
+
+
+class Tracer(object):
+    """The Tracer is for tracing a request for web applications.
+
+    :type span_context: :class:`~opencensus.trace.span_context.SpanContext`
+    :param span_context: SpanContext encapsulates the current context within
+                         the request's trace.
+
+    :type sampler: :class:`~opencensus.trace.samplers.base.Sampler`
+    :param sampler: Instances of Sampler objects. Defaults to
+                    :class:`.ProbabilitySampler`. Other options include
+                    :class:`.AlwaysOnSampler` and :class:`.AlwaysOffSampler`.
+
+    :type exporter: :class:`~opencensus.trace.base_exporter.exporter`
+    :param exporter: Instances of exporter objects. Default to
+                     :class:`.Printexporter`. The rest options are
+                     :class:`.Fileexporter`, :class:`.Printexporter`,
+                     :class:`.Loggingexporter`, :class:`.Zipkinexporter`,
+                     :class:`.GoogleCloudexporter`
+    """
+    def __init__(
+            self,
+            span_context=None,
+            sampler=None,
+            exporter=None,
+            propagator=None):
+        if span_context is None:
+            span_context = SpanContext()
+
+        if sampler is None:
+            sampler = samplers.ProbabilitySampler()
+
+        if exporter is None:
+            exporter = print_exporter.PrintExporter()
+
+        if propagator is None:
+            propagator = \
+                trace_context_http_header_format.TraceContextPropagator()
+
+        self.span_context = span_context
+        self.sampler = sampler
+        self.exporter = exporter
+        self.propagator = propagator
+        self.tracer = self.get_tracer()
+        self.store_tracer()
+
+    def should_sample(self):
+        """Determine whether to sample this request or not.
+        If the context enables tracing, return True.
+        Else follow the decision of the sampler.
+
+        :rtype: bool
+        :returns: Whether to trace the request or not.
+        """
+        return self.sampler.should_sample(self.span_context)
+
+    def get_tracer(self):
+        """Return a tracer according to the sampling decision."""
+        sampled = self.should_sample()
+
+        if sampled:
+            self.span_context.trace_options.set_enabled(True)
+            return context_tracer.ContextTracer(
+                exporter=self.exporter,
+                span_context=self.span_context)
+        return noop_tracer.NoopTracer()
+
+    def store_tracer(self):
+        """Add the current tracer to thread_local"""
+        execution_context.set_opencensus_tracer(self)
+
+    def finish(self):
+        """End all spans."""
+        self.tracer.finish()
+
+    def span(self, name='span'):
+        """Create a new span with the trace using the context information.
+
+        :type name: str
+        :param name: The name of the span.
+
+        :rtype: :class:`~opencensus.trace.span.Span`
+        :returns: The Span object.
+        """
+        return self.tracer.span(name)
+
+    def start_span(self, name='span'):
+        return self.tracer.start_span(name)
+
+    def end_span(self):
+        """End a span. Update the span_id in SpanContext to the current span's
+        parent span id; Update the current span; Send the span to exporter.
+        """
+        self.tracer.end_span()
+
+    def current_span(self):
+        """Return the current span."""
+        return self.tracer.current_span()
+
+    def add_attribute_to_current_span(self, attribute_key, attribute_value):
+        """Add attribute to current span.
+
+        :type attribute_key: str
+        :param attribute_key: Attribute key.
+
+        :type attribute_value:str
+        :param attribute_value: Attribute value.
+        """
+        self.tracer.add_attribute_to_current_span(
+            attribute_key, attribute_value)
+
+    def trace_decorator(self):
+        """Decorator to trace a function."""
+
+        def decorator(func):
+
+            def wrapper(*args, **kwargs):
+                self.tracer.start_span(name=func.__name__)
+                return_value = func(*args, **kwargs)
+                self.tracer.end_span()
+                return return_value
+
+            return wrapper
+
+        return decorator

vllm/lib/python3.10/site-packages/opencensus/trace/tracers/__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.