boost-jaeger-client 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8c3902062745f1d65ab3400e82306b4ccfab44b93cdfa8a63251153b91691bc2
+  data.tar.gz: 99c38c57a426b74763b47b845e10d6be1472041536543dea4f958d8923d30deb
+SHA512:
+  metadata.gz: 7d1b85df28533d5e7893b44917ae1d11db06abda22c2f52e458eaab4e70499ce13f22464eb9bd3a2eed81fa4249f329c74c7f17aa2f67757fe9ff3046cecc314
+  data.tar.gz: 6822ba4b929df4333ceed3e00f7ec4372747b1a9dbefbab90406fb09f44d0ce318c534ac907a913d0a4887bea27e9720f7de4b2dd15fda91017656ad97aebfd2

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,47 @@
+require: rubocop-rspec
+
+AllCops:
+  Exclude:
+    - 'thrift/**/*'
+
+Style/Documentation:
+  Enabled: no
+
+Style/IfUnlessModifier:
+  Enabled: no
+
+RSpec/NestedGroups:
+  Max: 4
+
+RSpec/ExampleLength:
+  Enabled: no
+
+RSpec/MultipleExpectations:
+  Enabled: no
+
+Metrics/BlockLength:
+  Enabled: no
+
+Metrics/MethodLength:
+  Enabled: no
+
+Metrics/AbcSize:
+  Enabled: no
+
+Metrics/ClassLength:
+  Enabled: no
+
+Metrics/ParameterLists:
+  Enabled: no
+
+Lint/UnusedMethodArgument:
+  Enabled: no
+
+Style/FrozenStringLiteralComment:
+  Enabled: yes
+  EnforcedStyle: always
+  Include:
+    - 'lib/**/*'
+
+Metrics/LineLength:
+  Max: 120

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.14.4

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jaeger-client.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Indrek Juhkam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+Jaeger::Client
+================
+[![Gem Version](https://badge.fury.io/rb/jaeger-client.svg)](https://rubygems.org/gems/jaeger-client)
+[![Build Status](https://travis-ci.org/salemove/jaeger-client-ruby.svg)](https://travis-ci.org/salemove/jaeger-client-ruby)
+
+OpenTracing Tracer implementation for Jaeger in Ruby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jaeger-client'
+```
+
+## Usage
+
+```ruby
+require 'jaeger/client'
+OpenTracing.global_tracer = Jaeger::Client.build(host: 'localhost', port: 6831, service_name: 'echo')
+
+OpenTracing.start_active_span('span name') do
+  # do something
+
+  OpenTracing.start_active_span('inner span name') do
+    # do something else
+  end
+end
+```
+
+See [opentracing-ruby](https://github.com/opentracing/opentracing-ruby) for more examples.
+
+### Samplers
+
+#### Const sampler
+
+`Const` sampler always makes the same decision for new traces depending on the initialization value. Set `sampler` to: `Jaeger::Client::Samplers::Const.new(true)` to mark all new traces as sampled.
+
+#### Probabilistic sampler
+
+`Probabilistic` sampler samples traces with probability equal to `rate` (must be between 0.0 and 1.0). This can be enabled by setting `Jaeger::Client::Samplers::Probabilistic.new(rate: 0.1)`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/salemove/jaeger-client-ruby
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+RuboCop::RakeTask.new(:rubocop)
+
+task default: %i[rubocop spec]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'jaeger/client'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/boost-jaeger-client.gemspec

@@ -0,0 +1,31 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'jaeger/client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'boost-jaeger-client'
+  spec.version       = Jaeger::Client::VERSION
+  spec.authors       = ['kruczjak', 'SaleMove TechMovers']
+  spec.email         = ['kruczjak@gmail.com']
+
+  spec.summary       = 'OpenTracing Tracer implementation for Jaeger in Ruby'
+  spec.description   = ''
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.54.0'
+  spec.add_development_dependency 'rubocop-rspec', '~> 1.24.0'
+
+  spec.add_dependency 'opentracing', '~> 0.3'
+  spec.add_dependency 'thrift'
+end

data/lib/jaeger/client/carrier.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    # Carriers are used for inject and extract operations. A carrier should be a
+    # Hash or hash-like object. At a minimum, it should implement `[]`, `[]=`, and
+    # `each` shown here.
+    class Carrier
+      # [] retrieves a value by the given key
+      # @param key [String] key to retrieve the value
+      # @return [String] the desired value
+      def [](key); end
+
+      # []= sets the value for the given key
+      # @param key [String] key to set
+      # @param value [String] value to set
+      def []=(key, value); end
+
+      # each iterates over every key-value pair in the carrier
+      # @yield [key, value]
+      # @yieldparam key [String] the key of the tuple
+      # @yieldparam value [String] the value of the tuple
+      def each(&block); end
+    end
+  end
+end

data/lib/jaeger/client/collector.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'thread'
+
+module Jaeger
+  module Client
+    class Collector
+      def initialize
+        @buffer = Buffer.new
+      end
+
+      def send_span(span, end_time)
+        context = span.context
+        start_ts, duration = build_timestamps(span, end_time)
+        return if !context.sampled? && !context.debug?
+
+        @buffer << Jaeger::Thrift::Span.new(
+          'traceIdLow' => context.thrift_trace_id,
+          'traceIdHigh' => 0,
+          'spanId' => context.thrift_span_id,
+          'parentSpanId' => context.thrift_parent_id,
+          'operationName' => span.operation_name,
+          'references' => build_references(span.references || []),
+          'flags' => context.flags,
+          'startTime' => start_ts,
+          'duration' => duration,
+          'tags' => span.tags,
+          'logs' => span.logs
+        )
+      end
+
+      def retrieve
+        @buffer.retrieve
+      end
+
+      private
+
+      def build_references(references)
+        references.map do |ref|
+          Jaeger::Thrift::SpanRef.new(
+            'refType' => span_ref_type(ref.type),
+            'traceIdLow' => ref.context.thrift_trace_id,
+            'traceIdHigh' => 0,
+            'spanId' => ref.context.thrift_span_id
+          )
+        end
+      end
+
+      def build_timestamps(span, end_time)
+        start_ts = (span.start_time.to_f * 1_000_000).to_i
+        end_ts = (end_time.to_f * 1_000_000).to_i
+        duration = end_ts - start_ts
+        [start_ts, duration]
+      end
+
+      def span_ref_type(type)
+        case type
+        when OpenTracing::Reference::CHILD_OF
+          Jaeger::Thrift::SpanRefType::CHILD_OF
+        when OpenTracing::Reference::FOLLOWS_FROM
+          Jaeger::Thrift::SpanRefType::FOLLOWS_FROM
+        else
+          warn "Jaeger::Client with format #{type} is not supported yet"
+          nil
+        end
+      end
+
+      class Buffer
+        def initialize
+          @buffer = []
+          @mutex = Mutex.new
+        end
+
+        def <<(element)
+          @mutex.synchronize do
+            @buffer << element
+            true
+          end
+        end
+
+        def retrieve
+          @mutex.synchronize do
+            elements = @buffer.dup
+            @buffer.clear
+            elements
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/client/samplers/const.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    module Samplers
+      # Const sampler
+      #
+      # A sampler that always makes the same decision for new traces depending
+      # on the initialization value. Use `Jaeger::Client::Samplers::Const.new(true)`
+      # to mark all new traces as sampled.
+      class Const
+        def initialize(decision)
+          @decision = decision
+          @param = decision ? '1' : '0'
+        end
+
+        def sample?(*)
+          @decision
+        end
+
+        def type
+          'const'
+        end
+
+        attr_reader :param
+      end
+    end
+  end
+end

data/lib/jaeger/client/samplers/probabilistic.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    module Samplers
+      # Probabilistic sampler
+      #
+      # Sample a portion of traces using trace_id as the random decision
+      class Probabilistic
+        def initialize(rate: 0.001)
+          @param = rate.to_s
+          if rate < 0.0 || rate > 1.0
+            raise "Sampling rate must be between 0.0 and 1.0, got #{rate.inspect}"
+          end
+          @boundary = TraceId::TRACE_ID_UPPER_BOUND * rate
+        end
+
+        def sample?(trace_id)
+          @boundary >= trace_id
+        end
+
+        def type
+          'probabilistic'
+        end
+
+        attr_reader :param
+      end
+    end
+  end
+end

data/lib/jaeger/client/samplers.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'samplers/const'
+require_relative 'samplers/probabilistic'

data/lib/jaeger/client/scope.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    # Scope represents an OpenTracing Scope
+    #
+    # See http://www.opentracing.io for more information.
+    class Scope
+      def initialize(span, scope_stack, finish_on_close:)
+        @span = span
+        @scope_stack = scope_stack
+        @finish_on_close = finish_on_close
+        @closed = false
+      end
+
+      # Return the Span scoped by this Scope
+      #
+      # @return [Span]
+      attr_reader :span
+
+      # Close scope
+      #
+      # Mark the end of the active period for the current thread and Scope,
+      # updating the ScopeManager#active in the process.
+      def close
+        raise "Tried to close already closed span: #{inspect}" if @closed
+        @closed = true
+
+        @span.finish if @finish_on_close
+        removed_scope = @scope_stack.pop
+
+        if removed_scope != self # rubocop:disable Style/GuardClause
+          raise 'Removed non-active scope, ' \
+            "removed: #{removed_scope.inspect}, "\
+            "expected: #{inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/client/scope_manager/scope_identifier.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    class ScopeManager
+      # @api private
+      class ScopeIdentifier
+        def self.generate
+          # 65..90.chr are characters between A and Z
+          "opentracing_#{(0...8).map { rand(65..90).chr }.join}".to_sym
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/client/scope_manager/scope_stack.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    class ScopeManager
+      # @api private
+      class ScopeStack
+        def initialize
+          # Generate a random identifier to use as the Thread.current key. This is
+          # needed so that it would be possible to create multiple tracers in one
+          # thread (mostly useful for testing purposes)
+          @scope_identifier = ScopeIdentifier.generate
+        end
+
+        def push(scope)
+          store << scope
+        end
+
+        def pop
+          store.pop
+        end
+
+        def peek
+          store.last
+        end
+
+        private
+
+        def store
+          Thread.current[@scope_identifier] ||= []
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/client/scope_manager.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'scope_manager/scope_stack'
+require_relative 'scope_manager/scope_identifier'
+
+module Jaeger
+  module Client
+    # ScopeManager represents an OpenTracing ScopeManager
+    #
+    # See http://www.opentracing.io for more information.
+    #
+    # The ScopeManager interface abstracts both the activation of Span instances
+    # via ScopeManager#activate and access to an active Span/Scope via
+    # ScopeManager#active
+    #
+    class ScopeManager
+      def initialize
+        @scope_stack = ScopeStack.new
+      end
+
+      # Make a span instance active
+      #
+      # @param span [Span] the Span that should become active
+      # @param finish_on_close [Boolean] whether the Span should automatically be
+      #   finished when Scope#close is called
+      # @return [Scope] instance to control the end of the active period for the
+      #  Span. It is a programming error to neglect to call Scope#close on the
+      #  returned instance.
+      def activate(span, finish_on_close: true)
+        return active if active && active.span == span
+        scope = Scope.new(span, @scope_stack, finish_on_close: finish_on_close)
+        @scope_stack.push(scope)
+        scope
+      end
+
+      # Return active scope
+      #
+      # If there is a non-null Scope, its wrapped Span becomes an implicit parent
+      # (as Reference#CHILD_OF) of any newly-created Span at
+      # Tracer#start_active_span or Tracer#start_span time.
+      #
+      # @return [Scope] the currently active Scope which can be used to access the
+      #   currently active Span.
+      def active
+        @scope_stack.peek
+      end
+    end
+  end
+end

data/lib/jaeger/client/span/thrift_log_builder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    class Span
+      class ThriftLogBuilder
+        FIELDS = Jaeger::Thrift::Log::FIELDS
+        TIMESTAMP = FIELDS[Jaeger::Thrift::Log::TIMESTAMP].fetch(:name)
+        LOG_FIELDS = FIELDS[Jaeger::Thrift::Log::LOG_FIELDS].fetch(:name)
+
+        def self.build(timestamp, fields)
+          Jaeger::Thrift::Log.new(
+            TIMESTAMP => (timestamp.to_f * 1_000_000).to_i,
+            LOG_FIELDS => fields.map { |key, value| ThriftTagBuilder.build(key, value) }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/client/span/thrift_tag_builder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    class Span
+      class ThriftTagBuilder
+        FIELDS = Jaeger::Thrift::Tag::FIELDS
+        KEY = FIELDS[Jaeger::Thrift::Tag::KEY].fetch(:name)
+        VTYPE = FIELDS[Jaeger::Thrift::Tag::VTYPE].fetch(:name)
+        VLONG = FIELDS[Jaeger::Thrift::Tag::VLONG].fetch(:name)
+        VDOUBLE = FIELDS[Jaeger::Thrift::Tag::VDOUBLE].fetch(:name)
+        VBOOL = FIELDS[Jaeger::Thrift::Tag::VBOOL].fetch(:name)
+        VSTR = FIELDS[Jaeger::Thrift::Tag::VSTR].fetch(:name)
+
+        def self.build(key, value)
+          if value.is_a?(Integer)
+            Jaeger::Thrift::Tag.new(
+              KEY => key.to_s,
+              VTYPE => Jaeger::Thrift::TagType::LONG,
+              VLONG => value
+            )
+          elsif value.is_a?(Float)
+            Jaeger::Thrift::Tag.new(
+              KEY => key.to_s,
+              VTYPE => Jaeger::Thrift::TagType::DOUBLE,
+              VDOUBLE => value
+            )
+          elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            Jaeger::Thrift::Tag.new(
+              KEY => key.to_s,
+              VTYPE => Jaeger::Thrift::TagType::BOOL,
+              VBOOL => value
+            )
+          else
+            Jaeger::Thrift::Tag.new(
+              KEY => key.to_s,
+              VTYPE => Jaeger::Thrift::TagType::STRING,
+              VSTR => value.to_s
+            )
+          end
+        end
+      end
+    end
+  end
+end