hubstep 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 12049128293bd8dd6ebfd5a63eb7bab3d0d07307
+  data.tar.gz: 335afba8aa1d6a9f4376ce9af4309fe410491e5e
+SHA512:
+  metadata.gz: fad83ef49dc17ffb0a16ed7244ce3723d396cc5248832f0ddbb95efa5a4df207645c93fea20e1902639dcb3a70e9bc8ff028f71f419a344db19fe206479f366e
+  data.tar.gz: 2babb2d26a745b96661f5c65833dfb316228f23ef812ec7d918d17259e687c3a2c2553d678caad9b8cae0632e6649c4e3235b9e2cf7bc49fbd52372c3df1748c

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/bin/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/gems/

data/.rubocop.yml

@@ -0,0 +1,44 @@
+AllCops:
+  DisplayCopNames: true
+  Exclude:
+    - "bin/**/*"
+    - "vendor/**/*"
+
+Metrics/BlockLength:
+  Exclude:
+    - "hubstep.gemspec"
+
+Metrics/ClassLength:
+  Exclude:
+    - "test/**/*"
+
+Metrics/LineLength:
+  Max: 100
+
+Metrics/MethodLength:
+  Max: 15
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+
+Style/HashSyntax:
+  EnforcedStyle: ruby19_no_mixed_keys
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/SpaceInsideBlockBraces:
+  EnforcedStyleForEmptyBraces: space
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+  ConsistentQuotesInMultiline: true
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/TrailingCommaInLiteral:
+  EnforcedStyleForMultiline: comma

data/.ruby-version

@@ -0,0 +1 @@
+2.3.3

data/.travis.yml

@@ -0,0 +1,10 @@
+sudo: false
+notifications:
+  email: false
+language: ruby
+rvm:
+  - 2.3.3
+before_install: gem install bundler -v 1.13.6
+script:
+  - bundle exec rake test
+  - bundle exec rubocop

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at adam@roben.org. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Adam Roben
+
+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,131 @@
+# HubStep
+
+HubStep provides standard tracing via [LightStep][] for GitHub-style Ruby apps.
+
+[LightStep]: http://lightstep.com/
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hubstep'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hubstep
+
+## Usage
+
+The core of HubStep is [`HubStep::Tracer`][tracer]. This wraps
+`LightStep::Tracer` and provides a block-based API for tracing, and the ability
+to enable/disable tracing at runtime. Typical usage looks something like:
+
+```ruby
+require "hubstep"
+
+module MyApp
+  def self.tracer
+    @tracer ||= HubStep::Tracer.new(tags: { "environment" => MyApp.environment })
+  end
+
+  class Fribble
+    def frob
+      MyApp.tracer.span("fribble.frob") do |span|
+        # real work goes here
+        span.set_tag("result", "success")
+      end
+    end
+  end
+end
+```
+
+[tracer]: /lib/hubstep/tracer.rb
+
+In addition to explicit tracing like in the above example, HubStep provides
+automatic instrumentation for various libraries.
+
+### ActiveSupport::Notifications
+
+[`HubStep::Instrumenter`][instrumenter] wraps `ActiveSupport::Notifications`
+and automatically creates spans for any blocks passed to `#instrument`:
+
+```ruby
+require "hubstep/instrumenter"
+
+module MyApp
+  def self.instrumenter
+    @instrumenter ||= HubStep::Instrumenter.new(self.tracer, ActiveSupport::Notifications)
+  end
+
+  class Fribble
+    def frob
+      MyApp.instrumenter.instrument("fribble.frob") do |payload, span|
+        # real work goes here
+        span.set_tag("result", "success")
+      end
+    end
+  end
+end
+```
+
+[instrumenter]: /lib/hubstep/instrumenter.rb
+
+### Faraday
+
+[`HubStep::Faraday::Middlware`][fm] is a [Faraday][] middleware that wraps each
+request in a span.
+
+```ruby
+require "hubstep/faraday/middleware"
+
+module MyApp
+  def self.faraday
+    @faraday ||= Faraday.new do |b|
+                   b.request(:hubstep)
+                   b.adapter(:typhoeus)
+                 end
+  end
+end
+```
+
+[fm]: /lib/hubstep/faraday/middleware.rb
+[Faraday]: https://github.com/lostisland/faraday
+
+### Rack/Sinatra
+
+[`HubStep::Rack::Middleware`][rm] is a [Rack][]/[Sinatra][] middleware that wraps
+each request in a span. This middleware also enables or disables tracing for
+the duration of a request based on the return value of the proc passed to it.
+
+```ruby
+# config.ru
+
+require "hubstep/rack/middleware"
+
+use HubStep::Rack::Middleware, MyApp.tracer, ->(env) { MyApp.tracing_enabled?(env) }
+```
+
+[rm]: /lib/hubstep/rack/middleware.rb
+[Rack]: http://rack.github.io/
+[Sinatra]: http://www.sinatrarb.com/
+
+## Development
+
+After checking out the repo, run `script/bootstrap` to install dependencies. Then, run `rake test` to run the tests. You can also run `script/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/github/hubstep. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## 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,11 @@
+# frozen_string_literal: true
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/hubstep.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+# frozen_string_literal: true
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "hubstep/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "hubstep"
+  spec.version       = HubStep::VERSION
+  spec.authors       = ["Adam Roben"]
+  spec.email         = ["adam@roben.org"]
+
+  spec.summary       = "Standard LightStep tracing of GitHub Ruby apps"
+  spec.description   = "Makes it easy to trace Sinatra and Ruby apps that use GitHub conventions."
+  spec.homepage      = "https://github.com/github/hubstep"
+  spec.license       = "MIT"
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "lightstep", "~> 0.10.0"
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rubocop", "~> 0.46.0"
+  spec.add_development_dependency "rack-test", "~> 0.6"
+  spec.add_development_dependency "activesupport", "~> 4.0"
+  spec.add_development_dependency "faraday", "~> 0.10"
+  spec.add_development_dependency "pry-byebug"
+end

data/lib/hubstep/failbot.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "English"
+require "failbot"
+
+module LightStep
+  module Transport
+    class HTTPJSON # rubocop:disable Style/Documentation
+      # This reimplementation of LightStep::Transport::HTTPJSON#report reports
+      # network errors and other exceptions to Failbot.
+      module Failbot
+        class HTTPError < StandardError; end
+
+        # There's no way to call through to the normal implementation while getting
+        # access to the response object, so we just copy all the code here.
+        def report(report) # rubocop:disable Metrics/AbcSize
+          p report if @verbose >= 3
+
+          https = Net::HTTP.new(@host, @port)
+          https.use_ssl = @encryption == ENCRYPTION_TLS
+          req = Net::HTTP::Post.new("/api/v0/reports")
+          req["LightStep-Access-Token"] = @access_token
+          req["Content-Type"] = "application/json"
+          req["Connection"] = "keep-alive"
+          req.body = report.to_json
+          res = https.request(req)
+
+          puts res.to_s, res.body if @verbose >= 3
+
+          track_error(res)
+
+          nil
+        ensure
+          ::Failbot.report!($ERROR_INFO) if $ERROR_INFO
+        end
+
+        def track_error(res)
+          return unless res.is_a?(Net::HTTPClientError) || res.is_a?(Net::HTTPServerError)
+          exception = HTTPError.new("#{res.code} #{res.message}")
+          exception.set_backtrace(caller)
+          ::Failbot.report!(exception, response_body: res.body, response_uri: res.uri)
+        end
+      end
+
+      prepend Failbot
+    end
+  end
+end

data/lib/hubstep/faraday/middleware.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "English"
+require "faraday"
+
+module HubStep
+  module Faraday
+    # Faraday middlware for wrapping a request in a span.
+    #
+    # tracer = HubStep::Tracer.new
+    # Faraday.new do |b|
+    #   b.request(:hubstep, tracer)
+    #   b.adapter(:typhoeus)
+    # end
+    class Middleware < ::Faraday::Middleware
+      def initialize(app, tracer)
+        super(app)
+        @tracer = tracer
+      end
+
+      def call(request_env)
+        # We pass `finish: false` so that the span won't have its end time
+        # recorded until #on_complete runs (which could be after #call returns
+        # if the request is asynchronous).
+        @tracer.span("faraday", finish: false) do |span|
+          begin
+            span.configure { record_request(span, request_env) }
+            @app.call(request_env).on_complete do |response_env|
+              span.configure do
+                record_response(span, response_env)
+                span.finish if span.end_micros.nil?
+              end
+            end
+          ensure
+            span.configure { record_exception(span, $ERROR_INFO) }
+          end
+        end
+      end
+
+      private
+
+      def record_request(span, request_env)
+        method = request_env[:method].to_s.upcase
+        span.operation_name = "Faraday #{method}"
+        span.set_tag("component", "faraday")
+        span.set_tag("http.url", request_env[:url])
+        span.set_tag("http.method", method)
+      end
+
+      def record_response(span, response_env)
+        span.set_tag("http.status_code", response_env[:status])
+      end
+
+      def record_exception(span, exception)
+        return unless exception
+
+        # The on_complete block may not be called if an exception is
+        # thrown while processing the request, so we need to finish the
+        # span here.
+        @tracer.record_exception(span, exception)
+        span.finish if span.end_micros.nil?
+      end
+    end
+  end
+end
+
+Faraday::Request.register_middleware hubstep: HubStep::Faraday::Middleware

data/lib/hubstep/instrumenter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module HubStep
+  # Wrapper around ActiveSupport::Notifications (or any object with the same
+  # API) that traces instrumented blocks. Behaves identically to the underlying
+  # object except that blocks passed to #instrument will be passed two
+  # arguments instead of one: the payload Hash (as usual) and the Span that
+  # will represent this block of code in the trace. The Span can be used to set
+  # tags etc.
+  #
+  #   require "hubstep/instrumenter"
+  #
+  #   instrumenter = HubStep::Instrumenter.new(tracer, ActiveSupport::Notifications)
+  #
+  #   def deflate(data)
+  #     # This block will be recorded as a span by the tracer and will also
+  #     # generate a notification as usual.
+  #     instrumenter.instrument("deflate.zlib") do |payload, span|
+  #       span.set_tag("bytesize", data.bytesize)
+  #       Zlib::Deflate.deflate(data)
+  #     end
+  #   end
+  class Instrumenter
+    # Creates an Instrumenter
+    #
+    # tracer  - HubStep::Tracer instance
+    # service - Object that provides ActiveSupport::Notifications' API (i.e.,
+    #           you could just pass ActiveSupport::Notifications here, or wrap
+    #           it in some other object).
+    def initialize(tracer, service)
+      @tracer = tracer
+      @service = service
+    end
+
+    def publish(name, *args)
+      service.publish(name, *args)
+    end
+
+    def instrument(name, payload = {})
+      @tracer.span(name) do |span|
+        service.instrument(name, payload) do |inner_payload|
+          yield inner_payload, span if block_given?
+        end
+      end
+    end
+
+    def subscribe(*args, &block)
+      service.subscribe(*args, &block)
+    end
+
+    def subscribed(callback, *args, &block)
+      service.subscribed(callback, *args, &block)
+    end
+
+    def unsubscribe(args)
+      service.unsubscribe(args)
+    end
+
+    private
+
+    attr_reader :service
+  end
+end

data/lib/hubstep/rack/middleware.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "rack"
+
+module HubStep
+  module Rack
+    # Rack middleware for wrapping a request in a span.
+    class Middleware
+      # Create a Middleware
+      #
+      # tracer    - a HubStep::Tracer instance
+      # enable_if - Proc that is passed the env for each request. If the Proc
+      #             returns true, the tracer will be enabled for the duration
+      #             of the request. If the Proc returns false, the tracer will
+      #             be disabled for the duration of the request.
+      def initialize(app, tracer, enable_if)
+        @app = app
+        @tracer = tracer
+        @enable_if = enable_if
+      end
+
+      def call(env)
+        @tracer.with_enabled(@enable_if.call(env)) do
+          trace(env) do
+            @app.call(env)
+          end
+        end
+      end
+
+      private
+
+      def trace(env)
+        @tracer.span("Rack #{env["REQUEST_METHOD"]}") do |span|
+          span.configure do
+            add_tags(span, ::Rack::Request.new(env))
+          end
+
+          result = yield
+
+          span.set_tag("http.status_code", result[0].to_s)
+
+          result
+        end
+      end
+
+      def add_tags(span, request)
+        tags(request).each do |key, value|
+          span.set_tag(key, value)
+        end
+      end
+
+      def tags(request)
+        tags = {
+          "component" => "rack",
+          "span.kind" => "server",
+          "http.url" => request.url,
+          "http.method" => request.request_method,
+        }
+        id = request_id(request)
+        if id
+          tags["guid:github_request_id"] = id
+        end
+
+        tags.freeze
+      end
+
+      def request_id(request)
+        request.env["HTTP_X_GITHUB_REQUEST_ID"]
+      end
+    end
+  end
+end

data/lib/hubstep/tracer.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "English"
+require "lightstep"
+require "singleton"
+
+module HubStep
+  # Tracer wraps LightStep::Tracer. It provides a block-based API for creating
+  # and configuring spans and support for enabling and disabling tracing at
+  # runtime.
+  class Tracer
+    # Create a Tracer.
+    #
+    # tags      - Hash of tags to assign to the tracer. These will be
+    #             associated with every span the tracer creates.
+    # transport - instance of a LightStep::Transport::Base subclass
+    def initialize(transport: default_transport, tags: {})
+      name = HubStep.server_metadata.values_at("app", "role").join("-")
+
+      default_tags = {
+        "hostname" => HubStep.hostname,
+      }
+
+      @tracer = LightStep::Tracer.new(component_name: name,
+                                      transport: transport,
+                                      tags: default_tags.merge(tags))
+      @spans = []
+      self.enabled = false
+    end
+
+    def enabled?
+      !!@enabled
+    end
+
+    # Enable/disable the tracer at runtime
+    #
+    # When disabled, all #span blocks will be passed InertSpans instead of real
+    # spans. Operations on InertSpan are no-ops.
+    attr_writer :enabled
+
+    # Enable/disable the tracer within a block
+    def with_enabled(value)
+      original = enabled?
+      self.enabled = value
+      yield
+    ensure
+      self.enabled = original
+    end
+
+    # Get the topmost span in the stack
+    #
+    # This is the span that has no parent span; the rest of the spans in the
+    # stack descend from it.
+    #
+    # Returns a LightStep::Span or InertSpan.
+    def top_span
+      span = @spans.first if enabled?
+      span || InertSpan.instance
+    end
+
+    # Get the bottommost span in the stack
+    #
+    # This is the span that has no children.
+    #
+    # Returns a LightStep::Span or InertSpan.
+    def bottom_span
+      span = @spans.last if enabled?
+      span || InertSpan.instance
+    end
+
+    # Record a span representing the execution of the given block
+    #
+    # operation_name - short human-readable String identifying the work done by the span
+    # start_time     - Time instance representing when the span began
+    # tags           - Hash of String => String tags to add to the span
+    # finish         - Boolean indicating whether to "finish" (i.e., record the
+    #                  span's end time and submit it to the collector).
+    #                  Defaults to true.
+    #
+    # Yields a LightStep::Span or InertSpan to the block. Returns the block's
+    # return value.
+    def span(operation_name, start_time: nil, tags: nil, finish: true)
+      unless enabled?
+        return yield InertSpan.instance
+      end
+
+      span = @tracer.start_span(operation_name,
+                                child_of: @spans.last,
+                                start_time: start_time,
+                                tags: tags)
+      @spans << span
+
+      begin
+        yield span
+      ensure
+        record_exception(span, $ERROR_INFO) if $ERROR_INFO
+
+        remove(span)
+
+        span.finish if finish && span.end_micros.nil?
+      end
+    end
+
+    # Record an exception that happened during a span
+    #
+    # span      - Span or InertSpan instance
+    # exception - Exception instance
+    #
+    # Returns nothing.
+    def record_exception(span, exception)
+      span.configure do
+        span.set_tag("error", true)
+        span.set_tag("error.class", exception.class.name)
+        span.set_tag("error.message", exception.message)
+      end
+    end
+
+    # Submit all buffered spans to the collector
+    #
+    # This happens automatically so you probably don't need to call this
+    # outside of tests.
+    #
+    # Returns nothing.
+    def flush
+      @tracer.flush if enabled?
+    end
+
+    private
+
+    def default_transport
+      host = ENV["LIGHTSTEP_COLLECTOR_HOST"]
+      port = ENV["LIGHTSTEP_COLLECTOR_PORT"]
+      encryption = ENV["LIGHTSTEP_COLLECTOR_ENCRYPTION"]
+      access_token = ENV["LIGHTSTEP_ACCESS_TOKEN"]
+
+      if host && port && encryption && access_token
+        LightStep::Transport::HTTPJSON.new(host: host,
+                                           port: port.to_i,
+                                           encryption: encryption,
+                                           access_token: access_token)
+      else
+        LightStep::Transport::Nil.new
+      end
+    end
+
+    def remove(span)
+      if span == @spans.last
+        # Common case
+        @spans.pop
+      else
+        @spans.delete(span)
+      end
+    end
+
+    # Mimics the interface and no-op behavior of OpenTracing::Span. This is
+    # used when tracing is disabled.
+    class InertSpan
+      include Singleton
+      instance.freeze
+
+      def configure
+      end
+
+      def operation_name=(name)
+      end
+
+      def set_tag(_key, _value)
+        self
+      end
+
+      def set_baggage_item(_key, _value)
+        self
+      end
+
+      def get_baggage_item(_key, _value)
+        nil
+      end
+
+      def log(event: nil, timestamp: nil, **fields) # rubocop:disable Lint/UnusedMethodArgument
+        nil
+      end
+
+      def finish(end_time: nil)
+      end
+    end
+  end
+end
+
+# rubocop:disable Style/Documentation
+module LightStep
+  class Span
+    module Configurable
+      def configure
+        yield self
+      end
+    end
+
+    include Configurable
+  end
+end
+# rubocop:enable Style/Documentation

data/lib/hubstep/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module HubStep
+  VERSION = "0.1.1"
+end

data/lib/hubstep.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "hubstep/tracer"
+require "hubstep/version"
+
+require "socket"
+
+#:nodoc:
+module HubStep
+  # Internal: Get this machine's hostname.
+  #
+  # Returns a String.
+  def self.hostname
+    @hostname ||= Socket.gethostname.freeze
+  end
+
+  # Internal: Reads server data written during provisioning.
+  #
+  # Returns a Hash.
+  def self.server_metadata
+    return @server_metadata if defined?(@server_metadata)
+    @server_metadata =
+      begin
+        JSON.parse(File.read("/etc/github/metadata.json")).freeze
+      rescue
+        {}.freeze
+      end
+  end
+end

data/script/bootstrap

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+set -e
+
+cd "$(dirname "$0")/.."
+
+bundle install --path vendor/gems --binstubs bin

data/script/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "hubstep"
+
+# 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

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: hubstep
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Adam Roben
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-12-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lightstep
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.46.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.46.0
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Makes it easy to trace Sinatra and Ruby apps that use GitHub conventions.
+email:
+- adam@roben.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hubstep.gemspec
+- lib/hubstep.rb
+- lib/hubstep/failbot.rb
+- lib/hubstep/faraday/middleware.rb
+- lib/hubstep/instrumenter.rb
+- lib/hubstep/rack/middleware.rb
+- lib/hubstep/tracer.rb
+- lib/hubstep/version.rb
+- script/bootstrap
+- script/console
+homepage: https://github.com/github/hubstep
+licenses:
+- MIT
+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.5.2
+signing_key: 
+specification_version: 4
+summary: Standard LightStep tracing of GitHub Ruby apps
+test_files: []