OT Collector trace exporter

examples/basic_tracer/README.md

@@ -53,6 +53,24 @@ Click on the trace to view its details.
 
 <p align="center"><img src="./images/jaeger-ui-detail.png?raw=true"/></p>
 
+### Collector
+
+* Start Collector
+
+```sh
+$ pip install docker-compose
+$ cd docker
+$ docker-compose up
+
+* Run the sample
+
+$ pip install opentelemetry-ext-otcollector
+$ # from this directory
+$ EXPORTER=collector python tracer.py
+
+
+
+
 ## Useful links
 - For more information on OpenTelemetry, visit: <https://opentelemetry.io/>
 - For more information on tracing in Python, visit: <https://github.com/open-telemetry/opentelemetry-python>

examples/basic_tracer/docker/collector-config.yaml

@@ -0,0 +1,18 @@
+receivers:
+  opencensus:
+    endpoint: "0.0.0.0:55678"
+
+exporters:
+  logging:
+    loglevel: debug
+
+processors:
+  batch:
+  queued_retry:
+
+service:
+  pipelines:
+    traces:
+      receivers: [opencensus]
+      exporters: [logging]
+      processors: [batch, queued_retry]

examples/basic_tracer/docker/docker-compose.yaml

@@ -0,0 +1,11 @@
+version: "2"
+services:
+
+  # Collector
+  collector:
+    image: omnition/opentelemetry-collector-contrib:latest
+    command: ["--config=/conf/collector-config.yaml", "--log-level=DEBUG"]
+    volumes:
+      - ./collector-config.yaml:/conf/collector-config.yaml
+    ports:
+      - "55678:55678"

examples/basic_tracer/tracer.py

@@ -27,12 +27,23 @@
 if os.getenv("EXPORTER") == "jaeger":
     from opentelemetry.ext.jaeger import JaegerSpanExporter
 
+    print("Using JaegerSpanExporter")
     exporter = JaegerSpanExporter(
         service_name="basic-service",
         agent_host_name="localhost",
         agent_port=6831,
     )
+elif os.getenv("EXPORTER") == "collector":
+    from opentelemetry.ext.otcollector.trace_exporter import (
+        CollectorSpanExporter,
+    )
+
+    print("Using CollectorSpanExporter")
+    exporter = CollectorSpanExporter(
+        service_name="basic-service", endpoint="localhost:55678"
+    )
 else:
+    print("Using ConsoleSpanExporter")
     exporter = ConsoleSpanExporter()
 
 # The preferred tracer implementation must be set, as the opentelemetry-api

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,166 @@
+# 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 = "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:
+        try:
+            responses = self.client.Export(self.generate_span_requests(spans))
+
+            #  # read response
+            for _ in responses:
+                pass
+
+        except grpc.RpcError:
+            return SpanExportResult.FAILED_NOT_RETRYABLE
+
+        return SpanExportResult.SUCCESS
+
+    def shutdown(self) -> None:
+        pass
+
+    def generate_span_requests(self, spans):
+        collector_spans = translate_to_collector(spans)
+        service_request = trace_service_pb2.ExportTraceServiceRequest(
+            node=self.node, spans=collector_spans
+        )
+        yield service_request
+
+
+# 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 and getattr(span.parent, "span_id", 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