OT Collector trace exporter

ext/opentelemetry-ext-otcollector/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Changelog
+
+## Unreleased
+

ext/opentelemetry-ext-otcollector/README.rst

@@ -0,0 +1,55 @@
+OpenTelemetry Collector Exporter
+=============================
+
+|pypi|
+
+.. |pypi| image:: https://badge.fury.io/py/opentelemetry-ext-otcollector.svg
+   :target: https://pypi.org/project/opentelemetry-ext-otcollector/
+
+This library allows to export data to `OpenTelemetry Collector <https://github.com/open-telemetry/opentelemetry-collector/>`_.
+
+Installation
+------------
+
+::
+
+     pip install opentelemetry-ext-otcollector
+
+
+Usage
+-----
+
+The **OpenTelemetry Collector Exporter** allows to export `OpenTelemetry`_ traces to `OpenTelemetry Collector`_.
+
+.. code:: python
+
+    from opentelemetry import trace
+    from opentelemetry.ext.otcollector import CollectorSpanExporter
+    from opentelemetry.sdk.trace import TracerSource
+    from opentelemetry.sdk.trace.export import BatchExportSpanProcessor
+
+    trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
+    tracer = trace.tracer_source().get_tracer(__name__)
+
+    # create a CollectorSpanExporter
+    collector_exporter = CollectorSpanExporter(
+        # optional:
+        # endpoint="http://myCollector:55678",
+        # service_name="test_service",
+        # host_name="http://localhost",
+    )
+
+    # Create a BatchExportSpanProcessor and add the exporter to it
+    span_processor = BatchExportSpanProcessor(collector_exporter)
+
+    # add to the tracer
+    trace.tracer_source().add_span_processor(span_processor)
+
+    with tracer.start_as_current_span("foo"):
+        print("Hello world!")
+
+References
+----------
+
+* `OpenTelemetry Collector <https://github.com/open-telemetry/opentelemetry-collector/>`_
+* `OpenTelemetry Project <https://opentelemetry.io/>`_

ext/opentelemetry-ext-otcollector/setup.cfg

@@ -0,0 +1,49 @@
+# Copyright 2020, OpenTelemetry 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.
+#
+[metadata]
+name = opentelemetry-ext-otcollector
+description = OpenTelemetry Collector Exporter
+long_description = file: README.rst
+long_description_content_type = text/x-rst
+author = OpenTelemetry Authors
+author_email = [email protected]
+url = https://github.com/open-telemetry/opentelemetry-python/ext/opentelemetry-ext-otcollector
+platforms = any
+license = Apache-2.0
+classifiers =
+    Development Status :: 3 - Alpha
+    Intended Audience :: Developers
+    License :: OSI Approved :: Apache Software License
+    Programming Language :: Python
+    Programming Language :: Python :: 3
+    Programming Language :: Python :: 3.4
+    Programming Language :: Python :: 3.5
+    Programming Language :: Python :: 3.6
+    Programming Language :: Python :: 3.7
+
+[options]
+python_requires = >=3.4
+package_dir=
+    =src
+packages=find_namespace:
+install_requires =
+    grpcio >= 1.0.0, < 2.0.0
+    opencensus-proto >= 0.1.0, < 1.0.0
+    opentelemetry-api
+    opentelemetry-sdk
+    protobuf
+
+[options.packages.find]
+where = src

ext/opentelemetry-ext-otcollector/setup.py

@@ -0,0 +1,26 @@
+# Copyright 2020, OpenTelemetry 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 os
+
+import setuptools
+
+BASE_DIR = os.path.dirname(__file__)
+VERSION_FILENAME = os.path.join(
+    BASE_DIR, "src", "opentelemetry", "ext", "otcollector", "version.py"
+)
+PACKAGE_INFO = {}
+with open(VERSION_FILENAME) as f:
+    exec(f.read(), PACKAGE_INFO)
+
+setuptools.setup(version=PACKAGE_INFO["__version__"])

ext/opentelemetry-ext-otcollector/src/opentelemetry/ext/otcollector/trace_exporter/__init__.py

@@ -0,0 +1,158 @@
+# Copyright 2020, OpenTelemetry 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.
+
+"""OpenTelemetry Collector Exporter."""
+
+import logging
+from typing import Optional, Sequence
+
+import grpc
+from opencensus.proto.agent.trace.v1 import (
+    trace_service_pb2,
+    trace_service_pb2_grpc,
+)
+from opencensus.proto.trace.v1 import trace_pb2
+
+import opentelemetry.ext.otcollector.util as utils
+from opentelemetry.sdk.trace import Span, SpanContext
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+from opentelemetry.trace import SpanKind, TraceState
+
+DEFAULT_ENDPOINT = "http://localhost:55678"
+
+logger = logging.getLogger(__name__)
+
+
+# pylint: disable=no-member
+class CollectorSpanExporter(SpanExporter):
+    """OpenTelemetry Collector span exporter.
+
+    Args:
+        endpoint: OpenTelemetry Collector OpenCensus receiver endpoint.
+        service_name: Name of Collector service.
+        host_name: Host name.
+        client: TraceService client stub.
+    """
+
+    def __init__(
+        self, endpoint=None, service_name=None, host_name=None, client=None
+    ):
+        self.endpoint = DEFAULT_ENDPOINT if endpoint is None else endpoint
+
+        if client is None:
+            self.channel = grpc.insecure_channel(self.endpoint)
+            self.client = trace_service_pb2_grpc.TraceServiceStub(
+                channel=self.channel
+            )
+        else:
+            self.client = client
+
+        self.node = utils.get_node(service_name, host_name)
+
+    def export(self, spans: Sequence[Span]) -> SpanExportResult:
+        collector_spans = translate_to_collector(spans)
+        export_request = trace_service_pb2.ExportTraceServiceRequest(
+            node=self.node, spans=collector_spans
+        )
+        try:
+            self.client.Export(export_request)
+        except grpc.RpcError:
+            return SpanExportResult.FAILED_NOT_RETRYABLE
+
+        return SpanExportResult.SUCCESS
+
+    def shutdown(self) -> None:
+        pass
+
+
+# pylint: disable=too-many-branches
+def translate_to_collector(spans: Sequence[Span]):
+    collector_spans = []
+    for span in spans:
+        collector_span = trace_pb2.Span(
+            name=trace_pb2.TruncatableString(value=span.name),
+            kind=utils.get_collector_span_kind(span.kind),
+            trace_id=span.context.trace_id.to_bytes(16, "big"),
+            span_id=span.context.span_id.to_bytes(8, "big"),
+            start_time=utils.proto_timestamp_from_time_ns(span.start_time),
+            end_time=utils.proto_timestamp_from_time_ns(span.end_time),
+            status=trace_pb2.Status(
+                code=span.status.canonical_code.value,
+                message=span.status.description,
+            )
+            if span.status is not None
+            else None,
+        )
+
+        if span.parent is not None:
+            collector_span.parent_span_id = span.parent.span_id.to_bytes(
+                8, "big"
+            )
+
+        if span.context.trace_state is not None:
+            for (key, value) in span.context.trace_state.items():
+                collector_span.tracestate.entries.add(key=key, value=value)
+
+        if span.attributes is not None:
+            for (key, value) in span.attributes.items():
+                utils.add_proto_attribute_value(
+                    collector_span.attributes, key, value
+                )
+
+        if span.events is not None:
+            for event in span.events:
+
+                collector_annotation = trace_pb2.Span.TimeEvent.Annotation(
+                    description=trace_pb2.TruncatableString(value=event.name)
+                )
+
+                for (key, value) in event.attributes.items():
+                    utils.add_proto_attribute_value(
+                        collector_annotation.attributes, key, value
+                    )
+
+                collector_span.time_events.time_event.add(
+                    time=utils.proto_timestamp_from_time_ns(event.timestamp),
+                    annotation=collector_annotation,
+                )
+
+        if span.links is not None:
+            for link in span.links:
+                collector_span_link = collector_span.links.link.add()
+                collector_span_link.trace_id = link.context.trace_id.to_bytes(
+                    16, "big"
+                )
+                collector_span_link.span_id = link.context.span_id.to_bytes(
+                    8, "big"
+                )
+                if (
+                    span.parent is not None
+                    and link.context.span_id == span.parent.span_id
+                    and link.context.trace_id == span.parent.trace_id
+                ):
+                    collector_span_link.type = (
+                        trace_pb2.Span.Link.Type.PARENT_LINKED_SPAN
+                    )
+                else:
+                    collector_span_link.type = (
+                        trace_pb2.Span.Link.Type.TYPE_UNSPECIFIED
+                    )
+
+                for (key, value) in link.attributes.items():
+                    utils.add_proto_attribute_value(
+                        collector_span_link.attributes, key, value
+                    )
+
+        collector_spans.append(collector_span)
+    return collector_spans

ext/opentelemetry-ext-otcollector/src/opentelemetry/ext/otcollector/util.py

@@ -0,0 +1,100 @@
+# Copyright 2020, OpenTelemetry 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 os
+import socket
+import time
+
+from google.protobuf.timestamp_pb2 import Timestamp
+from opencensus.proto.agent.common.v1 import common_pb2
+from opencensus.proto.trace.v1 import trace_pb2
+
+from opentelemetry.trace import SpanKind
+from opentelemetry.util.version import __version__ as opentelemetry_version
+
+# OT Collector exporter version
+EXPORTER_VERSION = "0.0.1"
+
+
+def proto_timestamp_from_time_ns(time_ns):
+    """Converts datetime to protobuf timestamp.
+
+    :type time_ns: int
+    :param time_ns: Time in nanoseconds
+
+    :rtype: :class:`~google.protobuf.timestamp_pb2.Timestamp`
+    :returns: protobuf timestamp
+    """
+    ts = Timestamp()
+    if time_ns is not None:
+        # pylint: disable=no-member
+        ts.FromNanoseconds(time_ns)
+    return ts
+
+
+# pylint: disable=no-member
+def get_collector_span_kind(kind: SpanKind):
+    if kind is SpanKind.SERVER:
+        return trace_pb2.Span.SpanKind.SERVER
+    if kind is SpanKind.CLIENT:
+        return trace_pb2.Span.SpanKind.CLIENT
+    return trace_pb2.Span.SpanKind.SPAN_KIND_UNSPECIFIED
+
+
+def add_proto_attribute_value(pb_attributes, key, value):
+    """Sets string, int, boolean or float value on protobuf
+        span, link or annotation attributes.
+
+    :type pb_attributes:
+        :class: `~opencensus.proto.trace.Span.Attributes`
+    :param pb_attributes: protobuf Span's attributes property
+
+    :type key: str
+    :param key: attribute key to set
+
+    :type value: str or int or bool or float
+    :param value: attribute value
+    """
+
+    if isinstance(value, bool):
+        pb_attributes.attribute_map[key].bool_value = value
+    elif isinstance(value, int):
+        pb_attributes.attribute_map[key].int_value = value
+    elif isinstance(value, str):
+        pb_attributes.attribute_map[key].string_value.value = value
+    elif isinstance(value, float):
+        pb_attributes.attribute_map[key].double_value = value
+    else:
+        pb_attributes.attribute_map[key].string_value.value = str(value)
+
+
+# pylint: disable=no-member
+def get_node(service_name, host_name):
+    """Generates Node message from params and system information.
+    """
+    return common_pb2.Node(
+        identifier=common_pb2.ProcessIdentifier(
+            host_name=socket.gethostname() if host_name is None else host_name,
+            pid=os.getpid(),
+            start_timestamp=proto_timestamp_from_time_ns(
+                int(time.time() * 1e9)
+            ),
+        ),
+        library_info=common_pb2.LibraryInfo(
+            language=common_pb2.LibraryInfo.Language.Value("PYTHON"),
+            exporter_version=EXPORTER_VERSION,
+            core_library_version=opentelemetry_version,
+        ),
+        service_info=common_pb2.ServiceInfo(name=service_name),
+    )