epsagon 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 036b9458b78db168edb2cb90dd4898f812eaa81a3e057abd69fc073fef9552d2
+  data.tar.gz: 1b2b2dce82f55073377db72400737a1243f8dab08426780d59f6a5faf62a2a13
+SHA512:
+  metadata.gz: 5bbbc9237c61ad7eb0818803eea213ed8b1003210b199c3c29355f1536b6dc4b7e990b628b92b8c015f4fab1c623eb92f07352d6c6cb5b6a00d0aeb12aa0dfc8
+  data.tar.gz: 81da4b0e55ecd53569564c22cfe1a986dce0835970bf3a522a7bc100e5b5a6c373275c6ac2bccd9d0a4500dddb8c26dca54d402d499116fa90201ba8de5edef5

data/lib/epsagon.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'net/http'
+require 'bundler/setup'
+require 'opentelemetry'
+
+require_relative 'instrumentation/sinatra'
+require_relative 'instrumentation/net_http'
+require_relative 'instrumentation/faraday'
+require_relative 'util'
+
+Bundler.require
+
+def metadata_only?
+  ENV['EPSAGON_METADATA']&.to_s&.downcase != 'false'
+end
+
+def debug?
+  ENV['EPSAGON_DEBUG']&.to_s&.downcase == 'true'
+end
+
+# #config opentelemetry with epsaon extensions:
+OpenTelemetry::SDK.configure do |c|
+  c.use 'EpsagonSinatraInstrumentation'
+  c.use 'EpsagonNetHTTPInstrumentation'
+  c.use 'EpsagonFaradayInstrumentation'
+  if ENV['EPSAGON_BACKEND']
+    c.add_span_processor OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
+      OpenTelemetry::Exporter::OTLP::Exporter.new(headers: {
+                            epasgon_token: ENV['EPSAGON_TOKEN'],
+                            epasgon_app_name: ENV['EPSAGON_APP_NAME']
+                          },
+                          endpoint: ENV['EPSAGON_BACKEND'],
+                          insecure: false)
+    )
+  else
+    c.add_span_processor OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
+      OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter.new
+    )
+  end
+end

data/lib/epsagon_opentelemetry.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'net/http'
+require 'bundler/setup'
+require 'opentelemetry'
+
+require_relative 'instrumentation/sinatra'
+require_relative 'instrumentation/net_http'
+require_relative 'instrumentation/faraday'
+require_relative 'util'
+
+Bundler.require
+
+def metadata_only?
+  ENV['EPSAGON_METADATA']&.to_s&.downcase != 'false'
+end
+
+def debug?
+  ENV['EPSAGON_DEBUG']&.to_s&.downcase == 'true'
+end
+
+# #config opentelemetry with epsaon extensions:
+OpenTelemetry::SDK.configure do |c|
+  c.use 'EpsagonSinatraInstrumentation'
+  c.use 'EpsagonNetHTTPInstrumentation'
+  c.use 'EpsagonFaradayInstrumentation'
+  if debug?
+    c.add_span_processor OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
+      OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter.new
+    )
+  else
+    c.add_span_processor OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
+      EpsagonExporter.new(headers: {
+                            epasgon_token: ENV['EPSAGON_TOKEN'],
+                            epasgon_app_name: ENV['EPSAGON_APP_NAME']
+                          },
+                          endpoint: '7fybd5lgpc.execute-api.us-east-2.amazonaws.com:443/dev/trace',
+                          insecure: false)
+    )
+  end
+end

data/lib/instrumentation/faraday.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require_relative '../util'
+
+class EpsagonFaradayMiddleware < ::Faraday::Middleware
+  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 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 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
+
+module EpsagonFaradayPatch
+  def adapter(*args)
+    use(:epsagon_open_telemetry) unless @handlers.any? do |handler|
+      handler.klass == EpsagonFaradayMiddleware
+    end
+
+    super
+  end
+end
+
+class EpsagonFaradayInstrumentation < OpenTelemetry::Instrumentation::Base
+  install do |_config|
+    ::Faraday::Middleware.register_middleware(
+      epsagon_open_telemetry: EpsagonFaradayMiddleware
+    )
+    ::Faraday::RackBuilder.prepend(EpsagonFaradayPatch)
+  end
+
+  present do
+    defined?(::Faraday)
+  end
+end

data/lib/instrumentation/net_http.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'opentelemetry'
+
+require_relative '../util'
+
+module EpsagonNetHTTPExtension
+  HTTP_METHODS_TO_SPAN_NAMES = Hash.new { |h, k| h[k] = "HTTP #{k}" }
+  USE_SSL_TO_SCHEME = { false => 'http', true => 'https' }.freeze
+
+  def request(req, body = nil, &block)
+    # Do not trace recursive call for starting the connection
+    return super(req, body, &block) unless started?
+
+    attributes = Hash[OpenTelemetry::Common::HTTP::ClientContext.attributes]
+    path_with_params, query = req.path.split('?')
+    path, path_params = path_with_params.split(';')
+    attributes.merge!({
+                        'type' => 'http',
+                        'operation' => req.method,
+                        'http.scheme' => USE_SSL_TO_SCHEME[use_ssl?],
+                        'http.request.path' => path
+                      })
+
+    unless metadata_only?
+      headers = Hash[req.each_header.to_a]
+      attributes.merge!({
+                          'http.request.path_params' => path_params,
+                          'http.request.body' => body,
+                          'http.request.headers' => headers.to_json,
+                          'http.request.headers.User-Agent' => headers['user-agent']
+                        })
+      attributes.merge!(Util.epsagon_query_attributes(query))
+    end
+    tracer.in_span(
+      @address,
+      attributes: attributes,
+      kind: :Client
+    ) do |span|
+      OpenTelemetry.propagation.http.inject(req)
+
+      super(req, body, &block).tap do |response|
+        annotate_span_with_response!(span, response)
+      end
+    end
+  end
+
+  private
+
+  def annotate_span_with_response!(span, response)
+    return unless response&.code
+
+    status_code = response.code.to_i
+
+    span.set_attribute('http.status_code', status_code)
+    unless metadata_only?
+      span.set_attribute('http.response.headers', Hash[response.each_header.to_a].to_json)
+      span.set_attribute('http.response.body', response.body)
+    end
+    span.status = OpenTelemetry::Trace::Status.http_to_status(
+      status_code
+    )
+  end
+
+  def tracer
+    EpsagonSinatraInstrumentation.instance.tracer
+  end
+end
+
+class EpsagonNetHTTPInstrumentation < OpenTelemetry::Instrumentation::Base
+  install do |_|
+    ::Net::HTTP.prepend(EpsagonNetHTTPExtension)
+  end
+
+  present do
+    defined?(::Net::HTTP)
+  end
+end

data/lib/instrumentation/sinatra.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'sinatra'
+require 'opentelemetry'
+
+require_relative '../util'
+
+class EpsagonTracerMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(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 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
+
+    tracer.in_span(
+      env['HTTP_HOST'],
+      attributes: attributes,
+      kind: :Server,
+      with_parent: parent_context(env)
+    ) do |http_span|
+      tracer.in_span('sinatra') do |framework_span|
+        app.call(env).tap { |resp| trace_response(http_span, framework_span, env, resp) }
+      end
+    end
+  end
+
+  private
+
+  attr_reader :app
+
+  def parent_context(env)
+    OpenTelemetry.propagation.http.extract(env)
+  end
+
+  def tracer
+    EpsagonSinatraInstrumentation.instance.tracer
+  end
+
+  def trace_response(http_span, framework_span, env, resp)
+    status, headers, response_body = resp
+
+    unless metadata_only?
+      http_span.set_attribute('http.response.headers', JSON.generate(headers))
+      http_span.set_attribute('http.response.body', response_body.join)
+    end
+
+    http_span.set_attribute('http.status_code', status)
+    framework_span.set_attribute('http.route', env['sinatra.route'].split.last) if env['sinatra.route']
+    http_span.status = OpenTelemetry::Trace::Status.http_to_status(status)
+  end
+end
+
+module EpsagonTracerExtension
+  # Sinatra hook after extension is registered
+  def self.registered(app)
+    # Create tracing `render` method
+    ::Sinatra::Base.module_eval do
+      def render(_engine, data, *)
+        template_name = data.is_a?(Symbol) ? data : :literal
+
+        Sinatra::Instrumentation.instance.tracer.in_span(
+          'sinatra.render_template',
+          attributes: { 'sinatra.template_name' => template_name.to_s }
+        ) do
+          super
+        end
+      end
+    end
+
+    app.use EpsagonTracerMiddleware
+  end
+end
+
+class EpsagonSinatraInstrumentation < OpenTelemetry::Instrumentation::Base
+  install do |_|
+    ::Sinatra::Base.register EpsagonTracerExtension
+  end
+
+  present do
+    defined?(::Sinatra)
+  end
+end

data/lib/util.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module Util
+  def self.epsagon_query_attributes(query_string)
+    if query_string&.include? '='
+      { 'http.request.query_params' => CGI.parse(query_string).to_json }
+    else
+      { 'http.request.query' => query_string }
+    end
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: epsagon
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Assaf Paneth
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-02-06 00:00:00.000000000 Z
+dependencies: []
+description: Epsagon for ruby
+email: assaf.paneth@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/epsagon.rb
+- lib/epsagon_opentelemetry.rb
+- lib/instrumentation/faraday.rb
+- lib/instrumentation/net_http.rb
+- lib/instrumentation/sinatra.rb
+- lib/util.rb
+homepage: https://rubygems.org/gems/epsagon
+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: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Epsagon for ruby
+test_files: []