opentracing_test_tracer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 38fb04d6afb859c67e42df9c64402e2b50e73d38
+  data.tar.gz: 8e56cb3ec69838de49f4b982944d25ed928c46ec
+SHA512:
+  metadata.gz: b4025e1c1bcbd0781bdf611b02989bb604c759b2438cec7843c0e05eb3963433df8cd0ec23e7c6d6273fdbe45cd54f5496fa141a442fc42c519a989e9f219330
+  data.tar.gz: c76904a409de65363b744b5cf73a65532b9607d58383957fefae9e642f9a3be808a4af33283485b32df248d175d1e636eb77e262dccacc4ae6b46d0da06019a0

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,46 @@
+require: rubocop-rspec
+
+Style/Documentation:
+  Enabled: no
+
+Style/IfUnlessModifier:
+  Enabled: no
+
+RSpec/NestedGroups:
+  Max: 4
+
+RSpec/ExampleLength:
+  Enabled: no
+
+RSpec/MultipleExpectations:
+  Enabled: no
+
+RSpec/FilePath:
+  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/.ruby-version

@@ -0,0 +1 @@
+2.3.4

data/.rubycop.yml

@@ -0,0 +1,43 @@
+require: rubocop-rspec
+
+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,7 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3
+  - 2.4
+  - 2.5
+before_install: gem install bundler -v 1.15.3

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in opentracing_ruby_tracer.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   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.

data/README.md

@@ -0,0 +1,66 @@
+# OpenTracingTestTracer
+
+OpenTracing compatible in-memory Tracer implementation. It exposes information about the recorded spans which are useful for testing.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'opentracing_test_tracer'
+```
+
+## Usage
+
+```ruby
+require 'opentracing_test_tracer'
+OpenTracing.global_tracer = OpenTracingTestTracer.build
+
+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.
+
+In addition to OpenTracing compatible methods this tracer provides following methods:
+
+### OpenTracingTestTracer
+
+1. `#spans` returns all spans, including those in progress.
+
+### OpenTracingTestTracer::Span
+
+1. `finished?` informs whether the span is finished.
+2. `start_time` returns when the span was started.
+3. `end_time` returns when the span was finished, or nil if still in progress.
+4. `tags` returns the span tags.
+5. `logs` returns the span logs.
+
+### OpenTracingTestTracer::SpanContext
+
+1. `trace_id` returns the trace ID.
+1. `span_id` returns the current span ID.
+2. `parent_id` returns the parent span ID.
+
+## 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/test-ruby-opentracing
+
+## Credits
+
+This gem is heavily inspired by @iaintshine [test-tracer](https://github.com/iaintshine/ruby-test-tracer).
+
+**opentracing_test_tracer** is maintained and funded by [SaleMove, Inc].
+
+[SaleMove, Inc]: http://salemove.com/ "SaleMove Website"

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+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,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'opentracing_test_tracer'
+
+# 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/lib/opentracing_test_tracer/scope.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class OpenTracingTestTracer
+  # 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

data/lib/opentracing_test_tracer/scope_manager/scope_identifier.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class OpenTracingTestTracer
+  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

data/lib/opentracing_test_tracer/scope_manager/scope_stack.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class OpenTracingTestTracer
+  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

data/lib/opentracing_test_tracer/scope_manager.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'scope_manager/scope_stack'
+require_relative 'scope_manager/scope_identifier'
+
+class OpenTracingTestTracer
+  # 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

data/lib/opentracing_test_tracer/span.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+class OpenTracingTestTracer
+  class Span
+    attr_accessor :operation_name
+
+    # NOTE: These are not OT compliant. These are meant only for testing.
+    attr_reader :context, :start_time, :tags, :logs, :references, :end_time
+
+    def initialize(
+      context:,
+      operation_name:,
+      start_time: Time.now,
+      tags: {},
+      references: nil
+    )
+      @context = context
+      @operation_name = operation_name
+      @start_time = start_time
+      @tags = tags
+      @logs = []
+      @references = references
+    end
+
+    # Set a tag value on this span
+    #
+    # @param key [String] the key of the tag
+    # @param value [String, Numeric, Boolean] the value of the tag. If it's not
+    # a String, Numeric, or Boolean it will be encoded with to_s
+    def set_tag(key, value)
+      sanitized_value = valid_tag_value?(value) ? value : value.to_s
+      @tags = @tags.merge(key.to_sym => sanitized_value)
+    end
+
+    # Set a baggage item on the span
+    #
+    # @param key [String] the key of the baggage item
+    # @param value [String] the value of the baggage item
+    def set_baggage_item(_key, _value)
+      self
+    end
+
+    # Get a baggage item
+    #
+    # @param key [String] the key of the baggage item
+    #
+    # @return Value of the baggage item
+    def get_baggage_item(_key)
+      nil
+    end
+
+    # Add a log entry to this span
+    #
+    # @deprecated Use {#log_kv} instead.
+    def log(*args)
+      warn 'Span#log is deprecated. Please use Span#log_kv instead.'
+      log_kv(*args)
+    end
+
+    # Add a log entry to this span
+    #
+    # @param timestamp [Time] time of the log
+    # @param fields [Hash] Additional information to log
+    def log_kv(timestamp: Time.now, **fields)
+      @logs << fields.merge(timestamp: timestamp)
+      nil
+    end
+
+    # Finish the {Span}
+    #
+    # @param end_time [Time] custom end time, if not now
+    def finish(end_time: Time.now)
+      @end_time = end_time
+    end
+
+    def to_s
+      "Span(operation_name=#{@operation_name}, " \
+        "tags=#{@tags}, " \
+        "logs=#{@logs}, " \
+        "start_time=#{@start_time}, " \
+        "end_time=#{@end_time}, " \
+        "context=#{@context})"
+    end
+
+    # NOTE: This is not OT compliant. This is meant only for testing.
+    def finished?
+      @end_time != nil
+    end
+
+    private
+
+    def valid_tag_value?(value)
+      value.is_a?(String) ||
+        value.is_a?(Numeric) ||
+        value.is_a?(TrueClass) ||
+        value.is_a?(FalseClass)
+    end
+  end
+end

data/lib/opentracing_test_tracer/span_context.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class OpenTracingTestTracer
+  # SpanContext holds the data for a span that gets inherited to child spans
+  class SpanContext
+    def self.create_parent_context
+      trace_id = TraceId.generate
+      new(trace_id: trace_id, span_id: trace_id)
+    end
+
+    def self.create_from_parent_context(span_context)
+      new(
+        span_id: TraceId.generate,
+        parent_id: span_context.span_id,
+        trace_id: span_context.trace_id
+      )
+    end
+
+    attr_reader :span_id, :parent_id, :trace_id, :baggage
+
+    def initialize(span_id:, parent_id: nil, trace_id:, baggage: {})
+      @span_id = span_id
+      @parent_id = parent_id
+      @trace_id = trace_id
+      @baggage = baggage
+    end
+
+    def to_s
+      "SpanContext(trace_id=#{@trace_id}, " \
+        "span_id=#{@span_id}, " \
+        "parent_id=#{@parent_id}, " \
+        "baggage=#{@baggage})"
+    end
+  end
+end

data/lib/opentracing_test_tracer/trace_id.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class OpenTracingTestTracer
+  module TraceId
+    TRACE_ID_UPPER_BOUND = 2**64
+
+    def self.generate
+      rand(TRACE_ID_UPPER_BOUND).to_s(16)
+    end
+  end
+end

data/lib/opentracing_test_tracer.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require 'opentracing'
+require 'logger'
+
+require_relative 'opentracing_test_tracer/span'
+require_relative 'opentracing_test_tracer/span_context'
+require_relative 'opentracing_test_tracer/trace_id'
+require_relative 'opentracing_test_tracer/scope_manager'
+require_relative 'opentracing_test_tracer/scope'
+
+class OpenTracingTestTracer
+  def self.build(logger: Logger.new(STDOUT))
+    new(logger: logger)
+  end
+
+  def initialize(logger:)
+    @logger = logger
+    @scope_manager = ScopeManager.new
+    @spans = []
+    @finished_spans = []
+  end
+
+  # NOTE: This is not OT compliant. This is meant only for testing.
+  attr_reader :spans
+
+  # @return [ScopeManager] the current ScopeManager, which may be a no-op but
+  #   may not be nil.
+  attr_reader :scope_manager
+
+  # @return [Span, nil] the active span. This is a shorthand for
+  #   `scope_manager.active.span`, and nil will be returned if
+  #   Scope#active is nil.
+  def active_span
+    scope = scope_manager.active
+    scope&.span
+  end
+
+  # Starts a new span
+  #
+  # This is similar to #start_active_span, but the returned Span will not be
+  # registered via the ScopeManager.
+  #
+  # @param operation_name [String] The operation name for the Span
+  # @param child_of [SpanContext, Span] SpanContext that acts as a parent to
+  #   the newly-started Span. If a Span instance is provided, its
+  #   context is automatically substituted. See [Reference] for more
+  #   information.
+  #
+  #   If specified, the `references` parameter must be omitted.
+  # @param references [Array<Reference>] An array of reference
+  #   objects that identify one or more parent SpanContexts.<Paste>
+  # @param start_time [Time] When the Span started, if not now
+  # @param tags [Hash] Tags to assign to the Span at start time
+  # @param ignore_active_scope [Boolean] whether to create an implicit
+  #   References#CHILD_OF reference to the ScopeManager#active.
+  #
+  # @return [Span] The newly-started Span
+  def start_span(operation_name,
+                 child_of: nil,
+                 start_time: Time.now,
+                 tags: nil,
+                 references: nil,
+                 ignore_active_scope: false,
+                 **)
+    context = prepare_span_context(
+      child_of: child_of,
+      references: references,
+      ignore_active_scope: ignore_active_scope
+    )
+    span = Span.new(
+      context: context,
+      operation_name: operation_name,
+      start_time: start_time,
+      references: references,
+      tags: tags
+    )
+    @spans << span
+    span
+  end
+
+  # Creates a newly started and activated Scope
+  #
+  # If the Tracer's ScopeManager#active is not nil, no explicit references
+  # are provided, and `ignore_active_scope` is false, then an inferred
+  # References#CHILD_OF reference is created to the ScopeManager#active's
+  # SpanContext when start_active is invoked.
+  #
+  # @param operation_name [String] The operation name for the Span
+  # @param child_of [SpanContext, Span] SpanContext that acts as a parent to
+  #   the newly-started Span. If a Span instance is provided, its
+  #   context is automatically substituted. See [Reference] for more
+  #   information.
+  #
+  #   If specified, the `references` parameter must be omitted.
+  # @param references [Array<Reference>] An array of reference
+  #   objects that identify one or more parent SpanContexts.
+  # @param start_time [Time] When the Span started, if not now
+  # @param tags [Hash] Tags to assign to the Span at start time
+  # @param ignore_active_scope [Boolean] whether to create an implicit
+  #   References#CHILD_OF reference to the ScopeManager#active.
+  # @param finish_on_close [Boolean] whether span should automatically be
+  #   finished when Scope#close is called
+  # @yield [Scope] If an optional block is passed to start_active it will
+  #   yield the newly-started Scope. If `finish_on_close` is true then the
+  #   Span will be finished automatically after the block is executed.
+  # @return [Scope] The newly-started and activated Scope
+  def start_active_span(operation_name,
+                        child_of: nil,
+                        references: nil,
+                        start_time: Time.now,
+                        tags: nil,
+                        ignore_active_scope: false,
+                        finish_on_close: true,
+                        **)
+    span = start_span(
+      operation_name,
+      child_of: child_of,
+      references: references,
+      start_time: start_time,
+      tags: tags,
+      ignore_active_scope: ignore_active_scope
+    )
+    scope = @scope_manager.activate(span, finish_on_close: finish_on_close)
+
+    if block_given?
+      begin
+        yield scope
+      ensure
+        scope.close
+      end
+    end
+
+    scope
+  end
+
+  # Inject a SpanContext into the given carrier
+  #
+  # @param span_context [SpanContext]
+  # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
+  # @param carrier [Carrier] A carrier object of the type dictated by the specified `format`
+  def inject(span_context, format, carrier)
+    case format
+    when OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_RACK
+      carrier['test-traceid'] = span_context.trace_id
+      carrier['test-parentspanid'] = span_context.parent_id
+      carrier['test-spanid'] = span_context.span_id
+    else
+      @logger.error "#{format} format is not supported yet"
+    end
+  end
+
+  # Extract a SpanContext in the given format from the given carrier.
+  #
+  # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
+  # @param carrier [Carrier] A carrier object of the type dictated by the specified `format`
+  # @return [SpanContext] the extracted SpanContext or nil if none could be found
+  def extract(format, carrier)
+    case format
+    when OpenTracing::FORMAT_TEXT_MAP
+      trace_id = carrier['test-traceid']
+      parent_id = carrier['test-parentspanid']
+      span_id = carrier['test-spanid']
+
+      create_span_context(trace_id, span_id, parent_id)
+    when OpenTracing::FORMAT_RACK
+      trace_id = carrier['HTTP_TEST_TRACEID']
+      parent_id = carrier['HTTP_TEST_PARENTSPANID']
+      span_id = carrier['HTTP_TEST_SPANID']
+
+      create_span_context(trace_id, span_id, parent_id)
+    else
+      @logger.error "#{format} format is not supported yet"
+      nil
+    end
+  end
+
+  private
+
+  def create_span_context(trace_id, span_id, parent_id)
+    return nil if !trace_id || !span_id
+
+    SpanContext.new(
+      trace_id: trace_id,
+      parent_id: parent_id,
+      span_id: span_id
+    )
+  end
+
+  def prepare_span_context(child_of:, references:, ignore_active_scope:)
+    parent_context =
+      context_from_child_of(child_of) ||
+      context_from_references(references) ||
+      context_from_active_scope(ignore_active_scope)
+
+    if parent_context
+      SpanContext.create_from_parent_context(parent_context)
+    else
+      SpanContext.create_parent_context
+    end
+  end
+
+  def context_from_child_of(child_of)
+    return nil unless child_of
+    child_of.respond_to?(:context) ? child_of.context : child_of
+  end
+
+  def context_from_references(references)
+    return nil if !references || references.none?
+
+    # Prefer CHILD_OF reference if present
+    ref = references.detect do |reference|
+      reference.type == OpenTracing::Reference::CHILD_OF
+    end
+    (ref || references[0]).context
+  end
+
+  def context_from_active_scope(ignore_active_scope)
+    return if ignore_active_scope
+
+    active_scope = @scope_manager.active
+    active_scope&.span&.context
+  end
+end

data/opentracing_test_tracer.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'opentracing_test_tracer'
+  spec.version       = '0.1.0'
+  spec.authors       = ['SaleMove TechMovers']
+  spec.email         = ['techmovers@salemove.com']
+
+  spec.summary       = 'OpenTracing Tracer implementation for Tests in Ruby'
+  spec.description   = ''
+  spec.homepage      = 'https://github.com/salemove/test-ruby-opentracing'
+  spec.license       = 'Apache-2.0'
+
+  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.15'
+  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'
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: opentracing_test_tracer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- SaleMove TechMovers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.54.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.54.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.24.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.24.0
+- !ruby/object:Gem::Dependency
+  name: opentracing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- techmovers@salemove.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".rubycop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/opentracing_test_tracer.rb
+- lib/opentracing_test_tracer/scope.rb
+- lib/opentracing_test_tracer/scope_manager.rb
+- lib/opentracing_test_tracer/scope_manager/scope_identifier.rb
+- lib/opentracing_test_tracer/scope_manager/scope_stack.rb
+- lib/opentracing_test_tracer/span.rb
+- lib/opentracing_test_tracer/span_context.rb
+- lib/opentracing_test_tracer/trace_id.rb
+- opentracing_test_tracer.gemspec
+homepage: https://github.com/salemove/test-ruby-opentracing
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: OpenTracing Tracer implementation for Tests in Ruby
+test_files: []