opentelemetry-exporter-jaeger 0.6.0

data/lib/opentelemetry/exporter/jaeger/collector_exporter.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'uri'
+
+module OpenTelemetry
+  module Exporter
+    module Jaeger
+      # An OpenTelemetry trace exporter that sends spans over HTTP as Thrift Binary encoded Jaeger spans.
+      class CollectorExporter
+        SUCCESS = OpenTelemetry::SDK::Trace::Export::SUCCESS
+        FAILURE = OpenTelemetry::SDK::Trace::Export::FAILURE
+        private_constant(:SUCCESS, :FAILURE)
+
+        def initialize(endpoint: ENV.fetch('OTEL_EXPORTER_JAEGER_ENDPOINT', 'http://localhost:14268/api/traces'),
+                       username: ENV['OTEL_EXPORTER_JAEGER_USER'],
+                       password: ENV['OTEL_EXPORTER_JAEGER_PASSWORD'])
+          raise ArgumentError, "invalid url for Jaeger::CollectorExporter #{endpoint}" if invalid_url?(endpoint)
+          raise ArgumentError, 'username and password should either both be nil or both be set' if username.nil? != password.nil?
+
+          @transport = ::Thrift::HTTPClientTransport.new(endpoint)
+          unless username.nil? || password.nil?
+            authorization = Base64.strict_encode64("#{username}:#{password}")
+            auth_header = { 'Authorization': "Basic #{authorization}" }
+            @transport.add_headers(auth_header)
+          end
+          @serializer = ::Thrift::Serializer.new
+          @shutdown = false
+          @tracer = OpenTelemetry.tracer_provider.tracer
+        end
+
+        # Called to export sampled {OpenTelemetry::SDK::Trace::SpanData} structs.
+        #
+        # @param [Enumerable<OpenTelemetry::SDK::Trace::SpanData>] span_data the
+        #   list of recorded {OpenTelemetry::SDK::Trace::SpanData} structs to be
+        #   exported.
+        # @return [Integer] the result of the export.
+        def export(span_data)
+          return FAILURE if @shutdown
+
+          encoded_batches(span_data).each do |batch|
+            @transport.write(@serializer.serialize(batch))
+          end
+
+          untraced do
+            @transport.flush
+          end
+          SUCCESS
+        rescue StandardError => e
+          OpenTelemetry.logger.error("unexpected error in Jaeger::CollectorExporter#export - #{e}")
+          FAILURE
+        end
+
+        # Called when {OpenTelemetry::SDK::Trace::Tracer#shutdown} is called, if
+        # this exporter is registered to a {OpenTelemetry::SDK::Trace::Tracer}
+        # object.
+        def shutdown
+          @shutdown = true
+        end
+
+        private
+
+        def invalid_url?(url)
+          return true if url.nil? || url.strip.empty?
+
+          URI(url)
+          false
+        rescue URI::InvalidURIError
+          true
+        end
+
+        def untraced
+          @tracer.with_span(OpenTelemetry::Trace::Span.new) { yield }
+        end
+
+        def encoded_batches(span_data)
+          span_data.group_by(&:resource).map do |resource, spans|
+            process = Encoder.encoded_process(resource)
+            spans.map! { |span| Encoder.encoded_span(span) }
+            Thrift::Batch.new('process' => process, 'spans' => spans)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/exporter/jaeger/encoder.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# Copyright 2020 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Exporter
+    module Jaeger
+      # @api private
+      module Encoder # rubocop:disable Metrics/ModuleLength
+        extend self
+
+        EMPTY_ARRAY = [].freeze
+        LONG = Thrift::Tag::FIELDS[Thrift::Tag::VLONG][:name]
+        DOUBLE = Thrift::Tag::FIELDS[Thrift::Tag::VDOUBLE][:name]
+        STRING = Thrift::Tag::FIELDS[Thrift::Tag::VSTR][:name]
+        BOOL = Thrift::Tag::FIELDS[Thrift::Tag::VBOOL][:name]
+        KEY = Thrift::Tag::FIELDS[Thrift::Tag::KEY][:name]
+        TYPE = Thrift::Tag::FIELDS[Thrift::Tag::VTYPE][:name]
+        TYPE_MAP = {
+          LONG => Thrift::TagType::LONG,
+          DOUBLE => Thrift::TagType::DOUBLE,
+          STRING => Thrift::TagType::STRING,
+          BOOL => Thrift::TagType::BOOL
+        }.freeze
+        KIND_MAP = {
+          OpenTelemetry::Trace::SpanKind::SERVER => 'server',
+          OpenTelemetry::Trace::SpanKind::CLIENT => 'client',
+          OpenTelemetry::Trace::SpanKind::PRODUCER => 'producer',
+          OpenTelemetry::Trace::SpanKind::CONSUMER => 'consumer'
+        }.freeze
+        private_constant(:EMPTY_ARRAY, :LONG, :DOUBLE, :STRING, :BOOL, :KEY, :TYPE, :TYPE_MAP, :KIND_MAP)
+
+        def encoded_process(resource)
+          service_name = 'unknown'
+          tags = resource&.attribute_enumerator&.select do |key, value|
+            service_name = value if key == 'service.name'
+            key != 'service.name'
+          end
+          tags = encoded_tags(tags)
+          Thrift::Process.new('serviceName' => service_name, 'tags' => tags)
+        end
+
+        def encoded_tags(attributes)
+          attributes&.map do |key, value|
+            encoded_tag(key, value)
+          end || EMPTY_ARRAY
+        end
+
+        def encoded_tag(key, value)
+          value_key = case value
+                      when Integer then LONG
+                      when Float then DOUBLE
+                      when String, Array then STRING
+                      when false, true then BOOL
+                      end
+          value = value.to_json if value.is_a?(Array)
+          Thrift::Tag.new(
+            KEY => key,
+            TYPE => TYPE_MAP[value_key],
+            value_key => value
+          )
+        end
+
+        def encoded_span(span_data) # rubocop:disable Metrics/AbcSize
+          start_time = (span_data.start_timestamp.to_f * 1_000_000).to_i
+          duration = (span_data.end_timestamp.to_f * 1_000_000).to_i - start_time
+
+          Thrift::Span.new(
+            'traceIdLow' => int64(span_data.trace_id[8, 8]),
+            'traceIdHigh' => int64(span_data.trace_id[0, 8]),
+            'spanId' => int64(span_data.span_id),
+            'parentSpanId' => int64(span_data.parent_span_id),
+            'operationName' => span_data.name,
+            'references' => encoded_references(span_data.links),
+            'flags' => span_data.trace_flags.sampled? ? 1 : 0,
+            'startTime' => start_time,
+            'duration' => duration,
+            'tags' => encoded_tags(span_data.attributes) +
+                encoded_status(span_data.status) +
+                encoded_kind(span_data.kind) +
+                encoded_instrumentation_library(span_data.instrumentation_library),
+            'logs' => encoded_logs(span_data.events)
+          )
+        end
+
+        def encoded_kind(kind)
+          value = KIND_MAP[kind]
+          return EMPTY_ARRAY unless value
+
+          Array(
+            Thrift::Tag.new(
+              KEY => 'span.kind',
+              TYPE => Thrift::TagType::STRING,
+              STRING => value
+            )
+          )
+        end
+
+        def encoded_logs(events)
+          events&.map do |event|
+            Thrift::Log.new(
+              'timestamp' => (event.timestamp.to_f * 1_000_000).to_i,
+              'fields' => encoded_tags(event.attributes) + encoded_tags('name' => event.name)
+            )
+          end
+        end
+
+        def encoded_references(links)
+          links&.map do |link|
+            Thrift::SpanRef.new(
+              'refType' => Thrift::SpanRefType::CHILD_OF,
+              'traceIdLow' => int64(link.context.trace_id[16, 16]),
+              'traceIdHigh' => int64(link.context.trace_id[0, 16]),
+              'spanId' => int64(link.context.span_id)
+            )
+          end
+        end
+
+        def encoded_status(status)
+          # TODO: OpenTracing doesn't specify how to report non-HTTP (i.e. generic) status.
+          EMPTY_ARRAY
+        end
+
+        def encoded_instrumentation_library(instrumentation_library)
+          return EMPTY_ARRAY unless instrumentation_library
+
+          tags = []
+          tags << encoded_tag('otel.instrumentation_library.name', instrumentation_library.name) if instrumentation_library.name
+          tags << encoded_tag('otel.instrumentation_library.version', instrumentation_library.version) if instrumentation_library.version
+          tags
+        end
+
+        def int64(byte_string)
+          int = byte_string.unpack1('Q>')
+          int < (1 << 63) ? int : int - (1 << 64)
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/exporter/jaeger/transport.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Exporter
+    module Jaeger
+      # A Thrift-compatible UDP transport.
+      class Transport
+        def initialize(host, port)
+          @socket = UDPSocket.new
+          @socket.connect(host, port)
+          @buffer = ::Thrift::MemoryBufferTransport.new
+        end
+
+        def write(string)
+          @buffer.write(string)
+        end
+
+        def flush
+          @socket.send(@buffer.read(@buffer.available), 0)
+          @socket.flush
+        rescue Errno::ECONNREFUSED
+          OpenTelemetry.logger.warn('Unable to connect to Jaeger Agent')
+        rescue StandardError => e
+          OpenTelemetry.logger.warn("Unable to send spans: #{e.message}")
+        end
+
+        def open; end
+
+        def close; end
+      end
+    end
+  end
+end

data/lib/opentelemetry/exporter/jaeger/version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Exporter
+    module Jaeger
+      ## Current OpenTelemetry Jaeger exporter version
+      VERSION = '0.6.0'
+    end
+  end
+end

data/thrift/gen-rb/agent.rb

@@ -0,0 +1,120 @@
+#
+# Autogenerated by Thrift Compiler (0.12.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'thrift'
+require 'agent_types'
+
+module OpenTelemetry
+  module Exporter
+    module Jaeger
+      module Thrift
+        module Agent
+          class Client
+            include ::Thrift::Client
+
+            def emitZipkinBatch(spans)
+              send_emitZipkinBatch(spans)
+            end
+
+            def send_emitZipkinBatch(spans)
+              send_oneway_message('emitZipkinBatch', EmitZipkinBatch_args, :spans => spans)
+            end
+            def emitBatch(batch)
+              send_emitBatch(batch)
+            end
+
+            def send_emitBatch(batch)
+              send_oneway_message('emitBatch', EmitBatch_args, :batch => batch)
+            end
+          end
+
+          class Processor
+            include ::Thrift::Processor
+
+            def process_emitZipkinBatch(seqid, iprot, oprot)
+              args = read_args(iprot, EmitZipkinBatch_args)
+              @handler.emitZipkinBatch(args.spans)
+              return
+            end
+
+            def process_emitBatch(seqid, iprot, oprot)
+              args = read_args(iprot, EmitBatch_args)
+              @handler.emitBatch(args.batch)
+              return
+            end
+
+          end
+
+          # HELPER FUNCTIONS AND STRUCTURES
+
+          class EmitZipkinBatch_args
+            include ::Thrift::Struct, ::Thrift::Struct_Union
+            SPANS = 1
+
+            FIELDS = {
+              SPANS => {:type => ::Thrift::Types::LIST, :name => 'spans', :element => {:type => ::Thrift::Types::STRUCT, :class => ::OpenTelemetry::Exporter::Jaeger::Thrift::Zipkin::Span}}
+            }
+
+            def struct_fields; FIELDS; end
+
+            def validate
+            end
+
+            ::Thrift::Struct.generate_accessors self
+          end
+
+          class EmitZipkinBatch_result
+            include ::Thrift::Struct, ::Thrift::Struct_Union
+
+            FIELDS = {
+
+            }
+
+            def struct_fields; FIELDS; end
+
+            def validate
+            end
+
+            ::Thrift::Struct.generate_accessors self
+          end
+
+          class EmitBatch_args
+            include ::Thrift::Struct, ::Thrift::Struct_Union
+            BATCH = 1
+
+            FIELDS = {
+              BATCH => {:type => ::Thrift::Types::STRUCT, :name => 'batch', :class => ::OpenTelemetry::Exporter::Jaeger::Thrift::Batch}
+            }
+
+            def struct_fields; FIELDS; end
+
+            def validate
+            end
+
+            ::Thrift::Struct.generate_accessors self
+          end
+
+          class EmitBatch_result
+            include ::Thrift::Struct, ::Thrift::Struct_Union
+
+            FIELDS = {
+
+            }
+
+            def struct_fields; FIELDS; end
+
+            def validate
+            end
+
+            ::Thrift::Struct.generate_accessors self
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/thrift/gen-rb/agent_constants.rb

@@ -0,0 +1,17 @@
+#
+# Autogenerated by Thrift Compiler (0.12.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'thrift'
+require 'agent_types'
+
+module OpenTelemetry
+  module Exporter
+    module Jaeger
+      module Thrift
+      end
+    end
+  end
+end

data/thrift/gen-rb/agent_types.rb

@@ -0,0 +1,19 @@
+#
+# Autogenerated by Thrift Compiler (0.12.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'thrift'
+require 'jaeger_types'
+require 'zipkincore_types'
+
+
+module OpenTelemetry
+  module Exporter
+    module Jaeger
+      module Thrift
+      end
+    end
+  end
+end

data/thrift/gen-rb/collector.rb

@@ -0,0 +1,86 @@
+#
+# Autogenerated by Thrift Compiler (0.12.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'thrift'
+require 'jaeger_types'
+
+module OpenTelemetry
+  module Exporter
+    module Jaeger
+      module Thrift
+        module Collector
+          class Client
+            include ::Thrift::Client
+
+            def submitBatches(batches)
+              send_submitBatches(batches)
+              return recv_submitBatches()
+            end
+
+            def send_submitBatches(batches)
+              send_message('submitBatches', SubmitBatches_args, :batches => batches)
+            end
+
+            def recv_submitBatches()
+              result = receive_message(SubmitBatches_result)
+              return result.success unless result.success.nil?
+              raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'submitBatches failed: unknown result')
+            end
+
+          end
+
+          class Processor
+            include ::Thrift::Processor
+
+            def process_submitBatches(seqid, iprot, oprot)
+              args = read_args(iprot, SubmitBatches_args)
+              result = SubmitBatches_result.new()
+              result.success = @handler.submitBatches(args.batches)
+              write_result(result, oprot, 'submitBatches', seqid)
+            end
+
+          end
+
+          # HELPER FUNCTIONS AND STRUCTURES
+
+          class SubmitBatches_args
+            include ::Thrift::Struct, ::Thrift::Struct_Union
+            BATCHES = 1
+
+            FIELDS = {
+              BATCHES => {:type => ::Thrift::Types::LIST, :name => 'batches', :element => {:type => ::Thrift::Types::STRUCT, :class => ::OpenTelemetry::Exporter::Jaeger::Thrift::Batch}}
+            }
+
+            def struct_fields; FIELDS; end
+
+            def validate
+            end
+
+            ::Thrift::Struct.generate_accessors self
+          end
+
+          class SubmitBatches_result
+            include ::Thrift::Struct, ::Thrift::Struct_Union
+            SUCCESS = 0
+
+            FIELDS = {
+              SUCCESS => {:type => ::Thrift::Types::LIST, :name => 'success', :element => {:type => ::Thrift::Types::STRUCT, :class => ::OpenTelemetry::Exporter::Jaeger::Thrift::BatchSubmitResponse}}
+            }
+
+            def struct_fields; FIELDS; end
+
+            def validate
+            end
+
+            ::Thrift::Struct.generate_accessors self
+          end
+
+        end
+
+      end
+    end
+  end
+end