epsagon 0.0.7 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd8b447f6b5d8e9f1dc22ae3b5e11e05b5236e4c84acb54b940e2cbb04d4f2ac
-  data.tar.gz: 45822ce4a73671ac392e1f380b10a37b87fcf4ab2f292eb4e3255d289838a188
+  metadata.gz: cfe4b588a7d3aeac7ea954338f6814c1b733cdacaab175b8ab63711a09adb849
+  data.tar.gz: a18b237f3e75ff45e3866a4570ad4125951480366007f0700af412254e04fd5e
 SHA512:
-  metadata.gz: 3c4bcf3d0d267bc843610351b8eb5788e5e99613fbc7f40b36acfdada628c73d5b3f524b69b5ceaa0fda047abbc9e0bc18bdccd0edfe59f3aa2b52f8650e9fc8
-  data.tar.gz: e4440cffd10b7a003dbbeac40b3521a8f9465ef0a3bc3d30df2e87c62d02067c09863e1bf0f49129172cd1a3f5291c83a489bdc91d79a6f6f9a8cd3a96a64574
+  metadata.gz: 4b0e7b5e44f8941fe647e69cb4f59c86ce144eef01fe7c96a035652c8fede98d2b781d59f495a852e1c0919fa5af40fe6413e2ef2c6c2b9c3b4a013b5ebef5c0
+  data.tar.gz: d67ce25f32683d501729e1715e6427881f7a89fc730030ade43ca3df05402c8277237df9fb1f38c9a4e460f21863a076903c2c8f011b715b50b56d4be3e2b549

data/lib/epsagon.rb

@@ -9,6 +9,8 @@ require 'opentelemetry/exporter/otlp'
 require_relative 'instrumentation/sinatra'
 require_relative 'instrumentation/net_http'
 require_relative 'instrumentation/faraday'
+require_relative 'instrumentation/aws_sdk'
+require_relative 'instrumentation/rails'
 require_relative 'util'
 
 Bundler.require
@@ -39,6 +41,8 @@ module Epsagon
     configurator.use 'EpsagonSinatraInstrumentation', { epsagon: @@epsagon_config }
     configurator.use 'EpsagonNetHTTPInstrumentation', { epsagon: @@epsagon_config }
     configurator.use 'EpsagonFaradayInstrumentation', { epsagon: @@epsagon_config }
+    configurator.use 'EpsagonAwsSdkInstrumentation', { epsagon: @@epsagon_config }
+    configurator.use 'EpsagonRailsInstrumentation', { epsagon: @@epsagon_config }
 
     if @@epsagon_config[:debug]
       configurator.add_span_processor OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(

data/lib/instrumentation/aws_sdk.rb

@@ -2,32 +2,6 @@
 
 require_relative '../util'
 
-# AWS SDK plugin for epsagon instrumentation
-class EpsagonAwsPlugin < Seahorse::Client::Plugin
-  def add_handlers(handlers, _)
-    handlers.add(EpsagonAwsHandler, step: :validate)
-  end
-end
-
-# Generates Spans for all uses of AWS SDK
-class EpsagonAwsHandler < Seahorse::Client::Handler
-  def call(context)
-    tracer.in_span('') do |span|
-      @handler.call(context).tap do
-        span.set_attribute('aws.operation', context[:command])
-        span.set_attribute('aws.status_code', context[:status_code])
-        span.set_attribute('aws.service', context[:service_name])
-        span.set_attribute('aws.account_id', context[:account_id])
-        span.set_attribute('aws.status_code', context[:status_code])
-      end
-    end
-  end
-
-  def tracer
-    EpsagonAwsSdkInstrumentation.instance.tracer
-  end
-end
-
 # AWS SDK epsagon instrumentation
 class EpsagonAwsSdkInstrumentation < OpenTelemetry::Instrumentation::Base
   VERSION = '0.0.0'
@@ -143,6 +117,7 @@ class EpsagonAwsSdkInstrumentation < OpenTelemetry::Instrumentation::Base
   ].freeze
 
   install do |_|
+    require_relative 'aws_sdk_plugin'
     ::Seahorse::Client::Base.add_plugin(EpsagonAwsPlugin)
     loaded_constants.each { |klass| klass.add_plugin(EpsagonAwsPlugin) }
   end

data/lib/instrumentation/aws_sdk_plugin.rb

@@ -0,0 +1,33 @@
+require 'aws-sdk-core'
+require 'opentelemetry/common'
+require 'opentelemetry/sdk'
+
+def untraced
+  OpenTelemetry::Trace.with_span(OpenTelemetry::Trace::Span.new) { yield }
+end
+# AWS SDK plugin for epsagon instrumentation
+class EpsagonAwsPlugin < Seahorse::Client::Plugin
+  def add_handlers(handlers, _)
+    handlers.add(EpsagonAwsHandler, step: :validate)
+  end
+end
+
+# Generates Spans for all uses of AWS SDK
+class EpsagonAwsHandler < Seahorse::Client::Handler
+  def call(context)
+    tracer.in_span('') do |span|
+      untraced do
+        @handler.call(context).tap do
+          span.set_attribute('aws.service', context.client.class.to_s.split('::')[1].downcase)
+          span.set_attribute('aws.aws.operation', context.operation.name)
+          span.set_attribute('aws.region', context.client.config.region)
+          span.set_attribute('aws.status_code', context.http_response.status_code)
+        end
+      end
+    end
+  end
+
+  def tracer
+    EpsagonAwsSdkInstrumentation.instance.tracer
+  end
+end

data/lib/instrumentation/epsagon_faraday_middleware.rb

@@ -0,0 +1,74 @@
+
+require_relative '../util'
+require 'faraday'
+
+# Faraday middleware for epsagon instrumentaton
+class EpsagonFaradayMiddleware < ::Faraday::Middleware
+  def config
+    EpsagonFaradayInstrumentation.instance.config
+  end
+
+  HTTP_METHODS_SYMBOL_TO_STRING = {
+    connect: 'CONNECT',
+    delete: 'DELETE',
+    get: 'GET',
+    head: 'HEAD',
+    options: 'OPTIONS',
+    patch: 'PATCH',
+    post: 'POST',
+    put: 'PUT',
+    trace: 'TRACE'
+  }.freeze
+
+  def call(env)
+    http_method = HTTP_METHODS_SYMBOL_TO_STRING[env.method]
+    path, path_params = env.url.path.split(';')
+
+    attributes = {
+      'type' => 'http',
+      'operation' => http_method,
+      'http.scheme' => env.url.scheme,
+      'http.request.path' => path
+    }
+
+    unless config[:epsagon][:metadata_only]
+      attributes.merge!(Util.epsagon_query_attributes(env.url.query))
+      attributes.merge!({
+                          'http.request.path_params' => path_params,
+                          'http.request.headers' => env.request_headers.to_json,
+                          'http.request.body' => env.body,
+                          'http.request.headers.User-Agent' => env.request_headers['User-Agent']
+                        })
+    end
+
+    tracer.in_span(
+      env.url.host,
+      attributes: attributes,
+      kind: :client
+    ) do |span|
+      OpenTelemetry.propagation.http.inject(env.request_headers)
+
+      app.call(env).on_complete { |req| trace_response(span, req.response) }
+    end
+  end
+
+  private
+
+  attr_reader :app
+
+  def tracer
+    EpsagonFaradayInstrumentation.instance.tracer
+  end
+
+  def trace_response(span, response)
+    span.set_attribute('http.status_code', response.status)
+
+    unless config[:epsagon][:metadata_only]
+      span.set_attribute('http.response.headers', response.headers.to_json)
+      span.set_attribute('http.response.body', response.body)
+    end
+    span.status = OpenTelemetry::Trace::Status.http_to_status(
+      response.status
+    )
+  end
+end

data/lib/instrumentation/epsagon_rails_middleware.rb

@@ -0,0 +1,282 @@
+require 'opentelemetry/trace/status'
+
+
+module QueueTime
+	REQUEST_START = 'HTTP_X_REQUEST_START'
+	QUEUE_START = 'HTTP_X_QUEUE_START'
+	MINIMUM_ACCEPTABLE_TIME_VALUE = 1_000_000_000
+
+	module_function
+
+	def get_request_start(env, now = nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+	  header = env[REQUEST_START] || env[QUEUE_START]
+	  return unless header
+
+	  # nginx header is seconds in the format "t=1512379167.574"
+	  # apache header is microseconds in the format "t=1570633834463123"
+	  # heroku header is milliseconds in the format "1570634024294"
+	  time_string = header.to_s.delete('^0-9')
+	  return if time_string.nil?
+
+	  # Return nil if the time is clearly invalid
+	  time_value = "#{time_string[0, 10]}.#{time_string[10, 6]}".to_f
+	  return if time_value.zero? || time_value < MINIMUM_ACCEPTABLE_TIME_VALUE
+
+	  # return the request_start only if it's lesser than
+	  # current time, to avoid significant clock skew
+	  request_start = Time.at(time_value)
+	  now ||= Time.now.utc
+	  request_start.utc > now ? nil : request_start
+	rescue StandardError => e
+	  # in case of an Exception we don't create a
+	  # `request.queuing` span
+	  OpenTelemetry.logger.debug("[rack] unable to parse request queue headers: #{e}")
+	  nil
+	end
+end
+
+class EpsagonRackMiddleware # rubocop:disable Metrics/ClassLength
+  class << self
+    def allowed_rack_request_headers
+      @allowed_rack_request_headers ||= Array(config[:allowed_request_headers]).each_with_object({}) do |header, memo|
+        memo["HTTP_#{header.to_s.upcase.gsub(/[-\s]/, '_')}"] = build_attribute_name('http.request.headers.', header)
+      end
+    end
+
+    def allowed_response_headers
+      @allowed_response_headers ||= Array(config[:allowed_response_headers]).each_with_object({}) do |header, memo|
+        memo[header] = build_attribute_name('http.response.headers.', header)
+        memo[header.to_s.upcase] = build_attribute_name('http.response.headers.', header)
+      end
+    end
+
+    def build_attribute_name(prefix, suffix)
+      prefix + suffix.to_s.downcase.gsub(/[-\s]/, '_')
+    end
+
+    def config
+      EpsagonRailsInstrumentation.instance.config
+    end
+
+    private
+
+    def clear_cached_config
+      @allowed_rack_request_headers = nil
+      @allowed_response_headers = nil
+    end
+  end
+
+  EMPTY_HASH = {}.freeze
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env) # rubocop:disable Metrics/AbcSize
+    original_env = env.dup
+    extracted_context = OpenTelemetry.propagation.http.extract(env)
+    frontend_context = create_frontend_span(env, extracted_context)
+
+    # restore extracted context in this process:
+    OpenTelemetry::Context.with_current(frontend_context || extracted_context) do
+      request_span_name = create_request_span_name(env['REQUEST_URI'] || original_env['PATH_INFO'])
+      tracer.in_span(env['HTTP_HOST'] || 'unknown',
+                     attributes: request_span_attributes(env: env),
+                     kind: :server) do |http_span|
+        RackExtension.with_span(http_span) do
+          tracer.in_span('rails') do |framework_span|
+            @app.call(env).tap do |status, headers, response|
+              set_attributes_after_request(http_span, framework_span, status, headers, response)
+            end
+          end
+        end
+      end
+    end
+  ensure
+    finish_span(frontend_context)
+  end
+
+  private
+
+  # return Context with the frontend span as the current span
+  def create_frontend_span(env, extracted_context)
+    request_start_time = QueueTime.get_request_start(env)
+
+    return unless config[:record_frontend_span] && !request_start_time.nil?
+
+    span = tracer.start_span('http_server.proxy',
+                             with_parent: extracted_context,
+                             attributes: {
+                               'start_time' => request_start_time.to_f
+                             },
+                             kind: :server)
+
+    OpenTelemetry::Trace.context_with_span(span, parent_context: extracted_context)
+  end
+
+  def finish_span(context)
+    OpenTelemetry::Trace.current_span(context).finish if context
+  end
+
+  def tracer
+    EpsagonRailsInstrumentation.instance.tracer
+  end
+
+  def request_span_attributes(env:)
+    request = Rack::Request.new(env)
+    path, path_params = request.path.split(';')
+    request_headers = JSON.generate(Hash[*env.select { |k, _v| k.start_with? 'HTTP_' }
+      .collect { |k, v| [k.sub(/^HTTP_/, ''), v] }
+      .collect { |k, v| [k.split('_').collect(&:capitalize).join('-'), v] }
+      .sort
+      .flatten])
+
+    attributes = {
+      'operation' => env['REQUEST_METHOD'],
+      'type' => 'http',
+      'http.scheme' => env['PATH_INFO'],
+      'http.request.path' => path,
+      'http.request.headers' => request_headers
+    }
+
+    unless config[:epsagon][:metadata_only]
+      request.body.rewind
+      request_body = request.body.read
+      request.body.rewind
+
+      attributes.merge!(Util.epsagon_query_attributes(request.query_string))
+
+      attributes.merge!({
+                          'http.request.body' => request_body,
+                          'http.request.path_params' => path_params,
+                          'http.request.headers.User-Agent' => env['HTTP_USER_AGENT']
+                        })
+    end
+
+    attributes
+  end
+
+  # e.g., "/webshop/articles/4?s=1":
+  def fullpath(env)
+    query_string = env['QUERY_STRING']
+    path = env['SCRIPT_NAME'] + env['PATH_INFO']
+
+    query_string.empty? ? path : "#{path}?#{query_string}"
+  end
+
+  # https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/data-http.md#name
+  #
+  # recommendation: span.name(s) should be low-cardinality (e.g.,
+  # strip off query param value, keep param name)
+  #
+  # see http://github.com/open-telemetry/opentelemetry-specification/pull/416/files
+  def create_request_span_name(request_uri_or_path_info)
+    # NOTE: dd-trace-rb has implemented 'quantization' (which lowers url cardinality)
+    #       see Datadog::Quantization::HTTP.url
+
+    if (implementation = config[:url_quantization])
+      implementation.call(request_uri_or_path_info)
+    else
+      request_uri_or_path_info
+    end
+  end
+
+  def set_attributes_after_request(http_span, framework_span, status, headers, response)
+    unless config[:epsagon][:metadata_only]
+      http_span.set_attribute('http.response.headers', JSON.generate(headers))
+      http_span.set_attribute('http.response.body', response.join)
+    end
+
+    http_span.set_attribute('http.status_code', status)
+    http_span.status = OpenTelemetry::Trace::Status.http_to_status(status)
+  end
+
+  def allowed_request_headers(env)
+    return EMPTY_HASH if self.class.allowed_rack_request_headers.empty?
+
+    {}.tap do |result|
+      self.class.allowed_rack_request_headers.each do |key, value|
+        result[value] = env[key] if env.key?(key)
+      end
+    end
+  end
+
+  def allowed_response_headers(headers)
+    return EMPTY_HASH if headers.nil?
+    return EMPTY_HASH if self.class.allowed_response_headers.empty?
+
+    {}.tap do |result|
+      self.class.allowed_response_headers.each do |key, value|
+        if headers.key?(key)
+          result[value] = headers[key]
+        else
+          # do case-insensitive match:
+          headers.each do |k, v|
+            if k.upcase == key
+              result[value] = v
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def config
+    EpsagonRailsInstrumentation.instance.config
+  end
+end
+
+# class EpsagonRackInstrumentation < OpenTelemetry::Instrumentation::Base
+#   install do |config|
+#     require_dependencies
+
+#     retain_middleware_names if config[:retain_middleware_names]
+#   end
+
+#   present do
+#     defined?(::Rack)
+#   end
+
+#   private
+
+#   def require_dependencies
+#     require_relative 'middlewares/tracer_middleware'
+#   end
+
+#   MissingApplicationError = Class.new(StandardError)
+
+#   # intercept all middleware-compatible calls, retain class name
+#   def retain_middleware_names
+#     next_middleware = config[:application]
+#     raise MissingApplicationError unless next_middleware
+
+#     while next_middleware
+#       if next_middleware.respond_to?(:call)
+#         next_middleware.singleton_class.class_eval do
+#           alias_method :__call, :call
+
+#           def call(env)
+#             env['RESPONSE_MIDDLEWARE'] = self.class.to_s
+#             __call(env)
+#           end
+#         end
+#       end
+
+#       next_middleware = next_middleware.instance_variable_defined?('@app') &&
+#                         next_middleware.instance_variable_get('@app')
+#     end
+#   end
+# end
+
+
+class EpsagonRailtie < ::Rails::Railtie
+  config.before_initialize do |app|
+    # EpsagonRackInstrumentation.instance.install({})
+
+    app.middleware.insert_after(
+      ActionDispatch::RequestId,
+      EpsagonRackMiddleware
+    )
+  end
+end

data/lib/instrumentation/faraday.rb

@@ -1,79 +1,4 @@
 # frozen_string_literal: true
-
-require 'faraday'
-require_relative '../util'
-
-# Faraday middleware for epsagon instrumentaton
-class EpsagonFaradayMiddleware < ::Faraday::Middleware
-  def config
-    EpsagonFaradayInstrumentation.instance.config
-  end
-
-  HTTP_METHODS_SYMBOL_TO_STRING = {
-    connect: 'CONNECT',
-    delete: 'DELETE',
-    get: 'GET',
-    head: 'HEAD',
-    options: 'OPTIONS',
-    patch: 'PATCH',
-    post: 'POST',
-    put: 'PUT',
-    trace: 'TRACE'
-  }.freeze
-
-  def call(env)
-    http_method = HTTP_METHODS_SYMBOL_TO_STRING[env.method]
-    path, path_params = env.url.path.split(';')
-
-    attributes = {
-      'type' => 'http',
-      'operation' => http_method,
-      'http.scheme' => env.url.scheme,
-      'http.request.path' => path
-    }
-
-    unless config[:epsagon][:metadata_only]
-      attributes.merge!(Util.epsagon_query_attributes(env.url.query))
-      attributes.merge!({
-                          'http.request.path_params' => path_params,
-                          'http.request.headers' => env.request_headers.to_json,
-                          'http.request.body' => env.body,
-                          'http.request.headers.User-Agent' => env.request_headers['User-Agent']
-                        })
-    end
-
-    tracer.in_span(
-      env.url.host,
-      attributes: attributes,
-      kind: :client
-    ) do |span|
-      OpenTelemetry.propagation.http.inject(env.request_headers)
-
-      app.call(env).on_complete { |req| trace_response(span, req.response) }
-    end
-  end
-
-  private
-
-  attr_reader :app
-
-  def tracer
-    EpsagonFaradayInstrumentation.instance.tracer
-  end
-
-  def trace_response(span, response)
-    span.set_attribute('http.status_code', response.status)
-
-    unless config[:epsagon][:metadata_only]
-      span.set_attribute('http.response.headers', response.headers.to_json)
-      span.set_attribute('http.response.body', response.body)
-    end
-    span.status = OpenTelemetry::Trace::Status.http_to_status(
-      response.status
-    )
-  end
-end
-
 # Patch faraday to include middleware
 module EpsagonFaradayPatch
   def adapter(*args)
@@ -90,6 +15,7 @@ class EpsagonFaradayInstrumentation < OpenTelemetry::Instrumentation::Base
   VERSION = '0.0.0'
 
   install do |_config|
+    require_relative 'epsagon_faraday_middleware'
     ::Faraday::Middleware.register_middleware(
       epsagon_open_telemetry: EpsagonFaradayMiddleware
     )

data/lib/instrumentation/rails.rb

@@ -0,0 +1,64 @@
+  
+require 'opentelemetry'
+require 'rails'
+require "action_controller/railtie"
+
+require_relative '../util'
+
+module RackExtension
+  extend self
+
+  CURRENT_SPAN_KEY = OpenTelemetry::Context.create_key('current-span')
+
+  private_constant :CURRENT_SPAN_KEY
+
+  # Returns the current span from the current or provided context
+  #
+  # @param [optional Context] context The context to lookup the current
+  #   {Span} from. Defaults to Context.current
+  def current_span(context = nil)
+    context ||= OpenTelemetry::Context.current
+    context.value(CURRENT_SPAN_KEY) || OpenTelemetry::Trace::Span::INVALID
+  end
+
+  # Returns a context containing the span, derived from the optional parent
+  # context, or the current context if one was not provided.
+  #
+  # @param [optional Context] context The context to use as the parent for
+  #   the returned context
+  def context_with_span(span, parent_context: OpenTelemetry::Context.current)
+    parent_context.set_value(CURRENT_SPAN_KEY, span)
+  end
+
+  # Activates/deactivates the Span within the current Context, which makes the "current span"
+  # available implicitly.
+  #
+  # On exit, the Span that was active before calling this method will be reactivated.
+  #
+  # @param [Span] span the span to activate
+  # @yield [span, context] yields span and a context containing the span to the block.
+  def with_span(span)
+    OpenTelemetry::Context.with_value(CURRENT_SPAN_KEY, span) { |c, s| yield s, c }
+  end
+end
+  
+module MetalPatch
+  def dispatch(name, request, response)
+    rack_span = RackExtension.current_span
+    # rack_span.name = "#{self.class.name}##{name}" if rack_span.context.valid? && !request.env['action_dispatch.exception']
+    super(name, request, response)
+  end
+end
+
+
+
+class EpsagonRailsInstrumentation < OpenTelemetry::Instrumentation::Base
+    install do |_config|
+      require_relative 'epsagon_rails_middleware'
+      ::ActionController::Metal.prepend(MetalPatch)
+    end
+
+    present do
+      defined?(::Rails)
+    end
+end

data/lib/instrumentation/sinatra.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'sinatra'
 require 'opentelemetry'
 
 require_relative '../util'
@@ -49,7 +48,7 @@ class EpsagonTracerMiddleware
     tracer.in_span(
       env['HTTP_HOST'],
       attributes: attributes,
-      kind: :Server,
+      kind: :server,
       with_parent: parent_context(env)
     ) do |http_span|
       tracer.in_span('sinatra') do |framework_span|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: epsagon
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.12
 platform: ruby
 authors:
 - Epsagon
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-06 00:00:00.000000000 Z
+date: 2021-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -38,20 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.11.1
-- !ruby/object:Gem::Dependency
-  name: sinatra
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: opentelemetry-instrumentation-sinatra
   requirement: !ruby/object:Gem::Requirement
@@ -80,20 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.11.0
-- !ruby/object:Gem::Dependency
-  name: faraday
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
 description: 'Epsagon provides tracing to Ruby applications for the collection of
   distributed tracing and performance metrics to simplify complex architectures, eliminate
   manual work, visualize and correlate data to identify and fix problems fast.
@@ -106,8 +78,12 @@ extra_rdoc_files: []
 files:
 - lib/epsagon.rb
 - lib/instrumentation/aws_sdk.rb
+- lib/instrumentation/aws_sdk_plugin.rb
+- lib/instrumentation/epsagon_faraday_middleware.rb
+- lib/instrumentation/epsagon_rails_middleware.rb
 - lib/instrumentation/faraday.rb
 - lib/instrumentation/net_http.rb
+- lib/instrumentation/rails.rb
 - lib/instrumentation/sinatra.rb
 - lib/util.rb
 homepage: https://github.com/epsagon/epsagon-ruby