epsagon 0.0.23 → 0.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9067624373427de33a82ba42e8b58bcf6d102ed85b8aaf24c69f511e628f2329
-  data.tar.gz: 2532583c2fb18426b046df27fca70adeff280c9ca6178e5188b905e6e17caa06
+  metadata.gz: 1a17b55f2ce2ff35ca70dd51e8f8337041e202c528b6c691800d3e3b7b0d42c4
+  data.tar.gz: d93046c571faa2d35a681217cb12952c57c7bd3232e77a136a5954a5534541b1
 SHA512:
-  metadata.gz: e1b93087e00032717588067013467eacc613418e20792aa86c36d2840d6fc13052971793d34bf4c8c47a83e677a174adfd2d6f45e150de058910214e19596799
-  data.tar.gz: 2711a7e340eb7bc768970de0cb88112dd743ecbc843285c1d3daaf4e437b6cec30550dea24f8232dce008209d78a9d05ed42b9cc2f70eca8eb3315011ce48f9f
+  metadata.gz: 9290a8dee89f24588f93bca0ab331855cab0cd46e09fdae10c4bb0c00c7c61c35c6045bc6b41971639767fc46f30d241b49a45a89a51c29baaa734113188aa7a
+  data.tar.gz: 3c4c1b54d0b344bf7399f3d088cd22bebca010d2b063244b425693bcaa2ef0ced625ec3a0921d1d5ce0cf7effd81e90dc6e410d5c893f1062096c78ec66e795f

data/lib/arn_parser.rb

@@ -0,0 +1,27 @@
+#
+# Credit: https://gist.github.com/RulerOf/b9f5dd00a9911aba8271b57d3d269d7a
+#
+class Arn
+  attr_accessor :partition, :service, :region, :account, :resource
+
+  def initialize(partition, service, region, account, resource)
+    @partition = partition
+    @service = service
+    @region = region
+    @account = account
+    @resource = resource
+  end
+
+  def self.parse(arn)
+    raise TypeError, 'ARN must be supplied as a string' unless arn.is_a?(String)
+
+    arn_components = arn.split(':', 6)
+    raise ArgumentError, 'Could not parse ARN' if arn_components.length < 6
+
+    Arn.new arn_components[1],
+            arn_components[2],
+            arn_components[3],
+            arn_components[4],
+            arn_components[5]
+  end
+end

data/lib/epsagon.rb

@@ -1,70 +1,98 @@
 # frozen_string_literal: true
-
+require 'json'
 require 'rubygems'
 require 'net/http'
 require 'bundler/setup'
 require 'opentelemetry/sdk'
 require 'opentelemetry/exporter/otlp'
+require 'opentelemetry/instrumentation/sidekiq'
 
 require_relative 'instrumentation/sinatra'
 require_relative 'instrumentation/net_http'
 require_relative 'instrumentation/faraday'
 require_relative 'instrumentation/aws_sdk'
 require_relative 'instrumentation/rails'
+require_relative 'instrumentation/postgres'
 require_relative 'util'
 require_relative 'epsagon_constants'
+require_relative 'exporter_extension'
+require_relative 'arn_parser'
 
 Bundler.require
 
 # Epsagon tracing main entry point
 module Epsagon
-  
   DEFAULT_BACKEND = 'opentelemetry.tc.epsagon.com:443/traces'
+  DEFAULT_IGNORE_DOMAINS = ['newrelic.com'].freeze
 
-  @@epsagon_config = {
-    metadata_only: ENV['EPSAGON_METADATA']&.to_s&.downcase != 'false',
-    debug: ENV['EPSAGON_DEBUG']&.to_s&.downcase == 'true',
-    token: ENV['EPSAGON_TOKEN'],
-    app_name: ENV['EPSAGON_APP_NAME'],
-    max_attribute_size: ENV['EPSAGON_MAX_ATTRIBUTE_SIZE'] || 5000,
-    backend: ENV['EPSAGON_BACKEND'] || DEFAULT_BACKEND
-  }
+  @@epsagon_config = nil
 
   module_function
 
   def init(**args)
-    @@epsagon_config.merge!(args)
+    get_config.merge!(args)
     OpenTelemetry::SDK.configure
   end
 
   def get_config
-    @@epsagon_config
+    @@epsagon_config ||= {
+      metadata_only: ENV['EPSAGON_METADATA']&.to_s&.downcase != 'false',
+      debug: ENV['EPSAGON_DEBUG']&.to_s&.downcase == 'true',
+      token: ENV['EPSAGON_TOKEN'] || '',
+      app_name: ENV['EPSAGON_APP_NAME'] || '',
+      max_attribute_size: ENV['EPSAGON_MAX_ATTRIBUTE_SIZE'] || 5000,
+      backend: ENV['EPSAGON_BACKEND'] || DEFAULT_BACKEND,
+      ignore_domains: ENV['EPSAGON_IGNORE_DOMAINS'] || DEFAULT_IGNORE_DOMAINS
+    }
+  end
+
+  def set_ecs_metadata
+    metadata_uri = ENV['ECS_CONTAINER_METADATA_URI']
+    return {} if metadata_uri.nil?
+
+    response = Net::HTTP.get(URI(metadata_uri))
+    ecs_metadata = JSON.parse(response)
+    arn = Arn.parse(ecs_metadata['Labels']['com.amazonaws.ecs.task-arn'])
+
+    {
+      'aws.account_id' => arn.account,
+      'aws.region' => arn.region,
+      'aws.ecs.cluster' => ecs_metadata['Labels']['com.amazonaws.ecs.cluster'],
+      'aws.ecs.task_arn' => ecs_metadata['Labels']['com.amazonaws.ecs.task-arn'],
+      'aws.ecs.container_name' => ecs_metadata['Labels']['com.amazonaws.ecs.container-name'],
+      'aws.ecs.task.family' => ecs_metadata['Labels']['com.amazonaws.ecs.task-definition-family'],
+      'aws.ecs.task.revision' => ecs_metadata['Labels']['com.amazonaws.ecs.task-definition-version']
+    }
   end
 
   # config opentelemetry with epsaon extensions:
 
   def epsagon_confs(configurator)
+    otel_resource = {
+      'application' => get_config[:app_name],
+      'epsagon.version' => EpsagonConstants::VERSION,
+      'epsagon.metadata_only' => get_config[:metadata_only]
+    }.merge(set_ecs_metadata)
+
     configurator.resource = OpenTelemetry::SDK::Resources::Resource.telemetry_sdk.merge(
-      OpenTelemetry::SDK::Resources::Resource.create({ 
-        'application' => @@epsagon_config[:app_name],
-        'epsagon.version' => EpsagonConstants::VERSION
-      })
+      OpenTelemetry::SDK::Resources::Resource.create(otel_resource)
     )
-    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 }
-    # configurator.use 'OpenTelemetry::Instrumentation::Sidekiq'
 
+    configurator.use 'EpsagonSinatraInstrumentation', { epsagon: get_config }
+    configurator.use 'EpsagonNetHTTPInstrumentation', { epsagon: get_config }
+    configurator.use 'EpsagonFaradayInstrumentation', { epsagon: get_config }
+    configurator.use 'EpsagonAwsSdkInstrumentation', { epsagon: get_config }
+    configurator.use 'EpsagonRailsInstrumentation', { epsagon: get_config }
+    configurator.use 'OpenTelemetry::Instrumentation::Sidekiq', { epsagon: get_config }
+    configurator.use 'EpsagonPostgresInstrumentation', { epsagon: get_config }
 
-    if @@epsagon_config[:debug]
+    if get_config[:debug]
       configurator.add_span_processor OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
         OpenTelemetry::Exporter::OTLP::Exporter.new(headers: {
-                                                      'x-epsagon-token' => @@epsagon_config[:token]
+                                                      'x-epsagon-token' => get_config[:token]
                                                     },
-                                                    endpoint: @@epsagon_config[:backend],
-                                                    insecure: @@epsagon_config[:insecure] || false)
+                                                    endpoint: get_config[:backend],
+                                                    insecure: get_config[:insecure] || false)
       )
 
       configurator.add_span_processor OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
@@ -73,10 +101,10 @@ module Epsagon
     else
       configurator.add_span_processor OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
         exporter: OpenTelemetry::Exporter::OTLP::Exporter.new(headers: {
-                                                                'x-epsagon-token' => @@epsagon_config[:token]
+                                                                'x-epsagon-token' => get_config[:token]
                                                               },
-                                                              endpoint: @@epsagon_config[:backend],
-                                                              insecure: @@epsagon_config[:insecure] || false)
+                                                              endpoint: get_config[:backend],
+                                                              insecure: get_config[:insecure] || false)
       )
     end
   end
@@ -97,15 +125,89 @@ module SpanExtension
   def initialize(*args)
     super(*args)
     if @attributes
-      @attributes = Hash[@attributes.map { |k,v|
+      @attributes = Hash[@attributes.select {|k,v| not BLANKS.include? v}.map { |k,v|
         [k, Util.trim_attr(v, Epsagon.get_config[:max_attribute_size])]
       }]
     end
-    
+  end
+end
+
+module SidekiqClientMiddlewareExtension
+  def call(_worker_class, job, _queue, _redis_pool)
+    config = OpenTelemetry::Instrumentation::Sidekiq::Instrumentation.instance.config[:epsagon] || {}
+    attributes = {
+      'operation' => job['at'] ? 'perform_at' : 'perform_async',
+      'messaging.system' => 'sidekiq',
+      'messaging.sidekiq.job_class' => job['wrapped']&.to_s || job['class'],
+      'messaging.message_id' => job['jid'],
+      'messaging.destination' => job['queue'],
+      'messaging.destination_kind' => 'queue',
+      'messaging.sidekiq.redis_url' => Sidekiq.options['url'] || Util.redis_default_url
+    }
+    unless config[:metadata_only]
+      attributes.merge!({
+        'messaging.sidekiq.args' => JSON.dump(job['args'])
+      })
+    end
+    tracer.in_span(
+      job['queue'],
+      attributes: attributes,
+      kind: :producer
+    ) do |span|
+      OpenTelemetry.propagation.text.inject(job)
+      span.add_event('created_at', timestamp: job['created_at'])
+      Util.untraced {yield}
+    end
+  end
+end
+
+module SidekiqServerMiddlewareExtension
+  def call(_worker, msg, _queue)
+    inner_exception = nil
+    config = OpenTelemetry::Instrumentation::Sidekiq::Instrumentation.instance.config[:epsagon] || {}
+    parent_context = OpenTelemetry.propagation.text.extract(msg)
+    attributes = {
+        'operation' => 'perform',
+        'messaging.system' => 'sidekiq',
+        'messaging.sidekiq.job_class' => msg['wrapped']&.to_s || msg['class'],
+        'messaging.message_id' => msg['jid'],
+        'messaging.destination' => msg['queue'],
+        'messaging.destination_kind' => 'queue',
+        'messaging.sidekiq.redis_url' => Sidekiq.options['url'] || Util.redis_default_url
+    }
+    runner_attributes = {
+      'type' => 'sidekiq_worker',
+      'messaging.sidekiq.redis_url' => Sidekiq.options['url'] || Util.redis_default_url,
+
+    }
+    unless config[:metadata_only]
+      attributes.merge!({
+        'messaging.sidekiq.args' => JSON.dump(msg['args'])
+      })
+    end
+    tracer.in_span(
+      msg['queue'],
+      attributes: attributes,
+      with_parent: parent_context,
+      kind: :consumer
+    ) do |trigger_span|
+      trigger_span.add_event('created_at', timestamp: msg['created_at'])
+      trigger_span.add_event('enqueued_at', timestamp: msg['enqueued_at'])
+      tracer.in_span(msg['wrapped']&.to_s || msg['class'],
+        attributes: runner_attributes,
+        kind: :consumer
+      ) do |runner_span|
+        yield
+      end
+    rescue Exception => e
+      inner_exception = e
+    end
+    raise inner_exception if inner_exception
   end
 end
 
 # monkey patch to include epsagon confs
+
 module OpenTelemetry
   # monkey patch inner SDK module
   module SDK
@@ -122,4 +224,35 @@ module OpenTelemetry
       end
     end
   end
+  module Instrumentation
+    module Sidekiq
+      class Instrumentation
+        def add_server_middleware
+          ::Sidekiq.configure_server do |config|
+            config.server_middleware do |chain|
+              chain.add Middlewares::Server::TracerMiddleware
+            end
+          end
+
+          if defined?(::Sidekiq::Testing) # rubocop:disable Style/GuardClause
+            ::Sidekiq::Testing.server_middleware do |chain|
+              chain.add Middlewares::Server::TracerMiddleware
+            end
+          end
+        end
+      end
+      module Middlewares
+        module Client
+          class TracerMiddleware
+            prepend SidekiqClientMiddlewareExtension
+          end
+        end
+        module Server
+          class TracerMiddleware
+            prepend SidekiqServerMiddlewareExtension
+          end
+        end
+      end
+    end
+  end
 end

data/lib/epsagon_constants.rb

@@ -1,3 +1,3 @@
 module EpsagonConstants
-	VERSION = '0.0.23'
+	VERSION = '0.0.28'
 end

data/lib/exporter_extension.rb

@@ -0,0 +1,78 @@
+
+
+module OpenTelemetry
+  module Exporter
+    module OTLP
+      # An OpenTelemetry trace exporter that sends spans over HTTP as Protobuf encoded OTLP ExportTraceServiceRequests.
+      class Exporter # rubocop:disable Metrics/ClassLength
+        def send_bytes(bytes, timeout:) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+          retry_count = 0
+          timeout ||= @timeout
+          start_time = Time.now
+          untraced do # rubocop:disable Metrics/BlockLength
+            request = Net::HTTP::Post.new(@path)
+            request.body = if @compression == 'gzip'
+                             request.add_field('Content-Encoding', 'gzip')
+                             Zlib.gzip(bytes)
+                           else
+                             bytes
+                           end
+            request.add_field('Content-Type', 'application/x-protobuf')
+            @headers&.each { |key, value| request.add_field(key, value) }
+
+            remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
+            return TIMEOUT if remaining_timeout.zero?
+
+            @http.open_timeout = remaining_timeout
+            @http.read_timeout = remaining_timeout
+            @http.write_timeout = remaining_timeout if WRITE_TIMEOUT_SUPPORTED
+            @http.start unless @http.started?
+            response = measure_request_duration { @http.request(request) }
+
+            case response
+            when Net::HTTPOK
+              response.body # Read and discard body
+              SUCCESS
+            when Net::HTTPServiceUnavailable, Net::HTTPTooManyRequests
+              response.body # Read and discard body
+              redo if backoff?(retry_after: response['Retry-After'], retry_count: retry_count += 1, reason: response.code)
+              FAILURE
+            when Net::HTTPRequestTimeOut, Net::HTTPGatewayTimeOut, Net::HTTPBadGateway
+              response.body # Read and discard body
+              redo if backoff?(retry_count: retry_count += 1, reason: response.code)
+              FAILURE
+            when Net::HTTPBadRequest, Net::HTTPClientError, Net::HTTPServerError
+              # TODO: decode the body as a google.rpc.Status Protobuf-encoded message when https://github.com/open-telemetry/opentelemetry-collector/issues/1357 is fixed.
+              response.body # Read and discard body
+              FAILURE
+            when Net::HTTPRedirection
+              @http.finish
+              handle_redirect(response['location'])
+              redo if backoff?(retry_after: 0, retry_count: retry_count += 1, reason: response.code)
+            else
+              @http.finish
+              FAILURE
+            end
+          rescue Net::OpenTimeout, Net::ReadTimeout
+            puts "Epsagon: timeout while sending trace" if Epsagon.get_config[:debug]
+            retry if backoff?(retry_count: retry_count += 1, reason: 'timeout')
+            return FAILURE
+          ensure
+            if Epsagon.get_config[:debug] && response && response.code.to_i >= 400
+              puts "Epsagon: Error while sending trace:"
+              puts "#{response.code} #{response.class.name} #{response.message}"
+              puts "Headers: #{response.to_hash.inspect}"
+              puts response.body
+            end
+          end
+        ensure
+          # Reset timeouts to defaults for the next call.
+          @http.open_timeout = @timeout
+          @http.read_timeout = @timeout
+          @http.write_timeout = @timeout if WRITE_TIMEOUT_SUPPORTED
+        end
+      end
+    end
+  end
+end
+

data/lib/instrumentation/aws_sdk_plugin.rb

@@ -4,6 +4,7 @@ require 'aws-sdk-core'
 require 'opentelemetry/common'
 require 'opentelemetry/sdk'
 
+
 def untraced(&block)
   OpenTelemetry::Trace.with_span(OpenTelemetry::Trace::Span.new, &block)
 end
@@ -17,14 +18,120 @@ end
 
 # Generates Spans for all uses of AWS SDK
 class EpsagonAwsHandler < Seahorse::Client::Handler
+  SPAN_KIND = {
+    'ReceiveMessage' => :consumer,
+    'SendMessage' => :producer,
+    'SendMessageBatch' => :producer,
+    'Publish' => :producer,
+  }
+
   def call(context)
-    tracer.in_span('', kind: :client) do |span|
+    span_name = ''
+    span_kind = :client
+    attributes = {
+      'aws.service' => context.client.class.to_s.split('::')[1].downcase,
+      'aws.operation' => context.operation.name
+    }  
+    attributes['aws.region'] = context.client.config.region unless attributes['aws.service'] == 's3'
+
+    span_kind = SPAN_KIND[attributes['aws.operation']] || span_kind
+    if attributes['aws.service'] == 's3'
+      attributes['aws.s3.bucket'] = context.params[:bucket]
+      span_name = attributes['aws.s3.bucket'] if attributes['aws.s3.bucket']
+      attributes['aws.s3.key'] = context.params[:key]
+      attributes['aws.s3.copy_source'] = context.params[:copy_source]
+    elsif attributes['aws.service'] == 'sqs'
+      queue_url = context.params[:queue_url]
+      queue_name = queue_url ? queue_url[queue_url.rindex('/')+1..-1] : context.params[:queue_name]
+      attributes['aws.sqs.max_number_of_messages'] = context.params[:max_number_of_messages]
+      attributes['aws.sqs.wait_time_seconds'] = context.params[:wait_time_seconds]
+      attributes['aws.sqs.visibility_timeout'] = context.params[:visibility_timeout]
+      attributes['aws.sqs.message_id'] = context.params[:message_id]
+      if queue_name
+        attributes['aws.sqs.queue_name'] = queue_name
+        span_name = attributes['aws.sqs.queue_name'] if attributes['aws.sqs.queue_name']
+      end
+      unless config[:epsagon][:metadata_only]
+        if attributes['aws.operation'] == 'SendMessageBatch'
+          messages_attributes = context.params[:entries].map do |m|
+            record = {
+              'message_attributes' => m[:message_attributes].map {|k,v| [k, v.to_h]},
+              'message_body' => m[:message_body],
+            } 
+          end
+          attributes['aws.sqs.record'] = JSON.dump(messages_attributes) if messages_attributes
+        end
+        attributes['aws.sqs.record.message_body'] = context.params[:message_body]
+        attributes['aws.sqs.record.message_attributes'] = JSON.dump(context.params[:message_attributes]) if context.params[:message_attributes]
+      end
+    elsif attributes['aws.service'] == 'sns'
+      topic_arn = context.params[:topic_arn]
+      topic_name = topic_arn ? topic_arn[topic_arn.rindex(':')+1..-1] : context.params[:name] 
+      span_name = attributes['aws.sns.topic_name'] = topic_name if topic_name
+      unless config[:epsagon][:metadata_only]
+        attributes['aws.sns.subject'] = context.params[:subject]
+        attributes['aws.sns.message'] = context.params[:message]
+        attributes['aws.sns.message_attributes'] = JSON.dump(context.params[:message_attributes]) if context.params[:message_attributes]
+      end
+    end
+    tracer.in_span(span_name, kind: span_kind, attributes: attributes) 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.operation', context.operation.name)
-          span.set_attribute('aws.region', context.client.config.region)
+        @handler.call(context).tap do |result|
+          if attributes['aws.service'] == 's3'
+            modified = context.http_response.headers[:'last-modified']
+            reformatted_modified = modified ? 
+                                  Time.strptime(modified, '%a, %d %b %Y %H:%M:%S %Z')
+                                  .strftime('%Y-%m-%dT%H:%M:%SZ') :
+                                  nil
+            if context.operation.name == 'GetObject'
+              span.set_attribute('aws.s3.content_length', context.http_response.headers[:'content-length']&.to_i)
+            end
+            span.set_attribute('aws.s3.etag', context.http_response.headers[:etag]&.tr('"',''))
+            span.set_attribute('aws.s3.last_modified', reformatted_modified)
+          elsif attributes['aws.service'] == 'sqs'
+            if context.operation.name == 'SendMessage'
+              span.set_attribute('aws.sqs.record.message_id', result.message_id)
+            end
+            if context.operation.name == 'SendMessageBatch'
+              messages_attributes = result.successful.map do |m|
+                record = {'message_id' => m.message_id}
+                unless config[:epsagon][:metadata_only]
+                  context.params[:entries].each do |e|
+                    record.merge!({
+                      'message_attributes' => e[:message_attributes].map {|k,v| [k, v.to_h]},
+                      'message_body' => e[:message_body],
+                    }) if e[:id] == m.id
+                  end
+                end
+                record
+              end
+              span.set_attribute('aws.sqs.record', JSON.dump(messages_attributes)) if messages_attributes
+            end
+            if context.operation.name == 'ReceiveMessage'
+              messages_attributes = result.messages.map do |m|
+                record = {
+                  'message_id' => m.message_id,
+                  'attributes' => {
+                    'sender_id' => m.attributes['SenderId'],
+                    'sent_timestamp' => m.attributes['SentTimestamp'],
+                    'aws_trace_header' => m.attributes['AWSTraceHeader'],
+                  }
+                }
+                unless config[:epsagon][:metadata_only]
+                  record['message_attributes'] = m.message_attributes.map {|k,v| [k, v.to_h]}
+                  record['message_body'] = m.body
+                end 
+                record
+              end
+              span.set_attribute('aws.sqs.record', JSON.dump(messages_attributes)) if messages_attributes
+            end
+          elsif attributes['aws.service'] == 'sns'
+            span.set_attribute('aws.sns.message_id', result.message_id) if context.operation.name == 'Publish'
+          end
           span.set_attribute('http.status_code', context.http_response.status_code)
+          span.status = OpenTelemetry::Trace::Status.http_to_status(
+            context.http_response.status_code
+          )
         end
       end
     end
@@ -33,4 +140,8 @@ class EpsagonAwsHandler < Seahorse::Client::Handler
   def tracer
     EpsagonAwsSdkInstrumentation.instance.tracer()
   end
+
+  def config
+    EpsagonAwsSdkInstrumentation.instance.config
+  end
 end

data/lib/instrumentation/epsagon_faraday_middleware.rb

@@ -37,11 +37,11 @@ class EpsagonFaradayMiddleware < ::Faraday::Middleware
     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']
-                        })
+        '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(

data/lib/instrumentation/epsagon_rails_middleware.rb

@@ -130,7 +130,7 @@ class EpsagonRackMiddleware
   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_' }
+    request_headers = JSON.generate(Hash[*env.select { |k, _v| k.to_s.start_with? 'HTTP_' }
       .collect { |k, v| [k.sub(/^HTTP_/, ''), v] }
       .collect { |k, v| [k.split('_').collect(&:capitalize).join('-'), v] }
       .sort
@@ -189,7 +189,7 @@ class EpsagonRackMiddleware
   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)
+      http_span.set_attribute('http.response.body', response.join) if response.respond_to?(:join)
     end
 
     http_span.set_attribute('http.status_code', status)

data/lib/instrumentation/net_http.rb

@@ -17,6 +17,7 @@ module EpsagonNetHTTPExtension
   def request(req, body = nil, &block)
     # Do not trace recursive call for starting the connection
     return super(req, body, &block) unless started?
+    return super(req, body, &block) if config[:epsagon][:ignore_domains].any? {|d| @address.include? d}
 
     attributes = Hash[OpenTelemetry::Common::HTTP::ClientContext.attributes]
     path_with_params, query = req.path.split('?')
@@ -55,6 +56,7 @@ module EpsagonNetHTTPExtension
 
   def annotate_span_with_response!(span, response)
     return unless response&.code
+    return unless span.respond_to?(:set_attribute)
 
     status_code = response.code.to_i
 

data/lib/instrumentation/postgres.rb

@@ -0,0 +1,294 @@
+require 'pg_query'
+
+module PostgresExtension
+  # A list of SQL commands, from: https://www.postgresql.org/docs/current/sql-commands.html
+  # Commands are truncated to their first word, and all duplicates
+  # are removed, This favors brevity and low-cardinality over descriptiveness.
+  SQL_COMMANDS = %w[
+    ABORT
+    ALTER
+    ANALYZE
+    BEGIN
+    CALL
+    CHECKPOINT
+    CLOSE
+    CLUSTER
+    COMMENT
+    COMMIT
+    COPY
+    CREATE
+    DEALLOCATE
+    DECLARE
+    DELETE
+    DISCARD
+    DO
+    DROP
+    END
+    EXECUTE
+    EXPLAIN
+    FETCH
+    GRANT
+    IMPORT
+    INSERT
+    LISTEN
+    LOAD
+    LOCK
+    MOVE
+    NOTIFY
+    PREPARE
+    PREPARE
+    REASSIGN
+    REFRESH
+    REINDEX
+    RELEASE
+    RESET
+    REVOKE
+    ROLLBACK
+    SAVEPOINT
+    SECURITY
+    SELECT
+    SELECT
+    SET
+    SHOW
+    START
+    TRUNCATE
+    UNLISTEN
+    UPDATE
+    VACUUM
+    VALUES
+  ].freeze
+
+  # From: https://github.com/newrelic/newrelic-ruby-agent/blob/9787095d4b5b2d8fcaf2fdbd964ed07c731a8b6b/lib/new_relic/agent/database/obfuscation_helpers.rb#L9-L34
+  COMPONENTS_REGEX_MAP = {
+    single_quotes: /'(?:[^']|'')*?(?:\\'.*|'(?!'))/,
+    dollar_quotes: /(\$(?!\d)[^$]*?\$).*?(?:\1|$)/,
+    uuids: /\{?(?:[0-9a-fA-F]\-*){32}\}?/,
+    numeric_literals: /-?\b(?:[0-9]+\.)?[0-9]+([eE][+-]?[0-9]+)?\b/,
+    boolean_literals: /\b(?:true|false|null)\b/i,
+    comments: /(?:#|--).*?(?=\r|\n|$)/i,
+    multi_line_comments: %r{\/\*(?:[^\/]|\/[^*])*?(?:\*\/|\/\*.*)}
+  }.freeze
+
+  POSTGRES_COMPONENTS = %i[
+    single_quotes
+    dollar_quotes
+    uuids
+    numeric_literals
+    boolean_literals
+    comments
+    multi_line_comments
+  ].freeze
+
+  UNMATCHED_PAIRS_REGEX = %r{'|\/\*|\*\/|\$(?!\?)}.freeze
+
+  # These are all alike in that they will have a SQL statement as the first parameter.
+  # That statement may possibly be parameterized, but we can still use it - the
+  # obfuscation code will just transform $1 -> $? in that case (which is fine enough).
+  EXEC_ISH_METHODS = %i[
+    exec
+    query
+    sync_exec
+    async_exec
+    exec_params
+    async_exec_params
+    sync_exec_params
+  ].freeze
+
+  # The following methods all take a statement name as the first
+  # parameter, and a SQL statement as the second - and possibly
+  # further parameters after that. We can trace them all alike.
+  PREPARE_ISH_METHODS = %i[
+    prepare
+    async_prepare
+    sync_prepare
+  ].freeze
+
+  # The following methods take a prepared statement name as their first
+  # parameter - everything after that is either potentially quite sensitive
+  # (an array of bind params) or not useful to us. We trace them all alike.
+  EXEC_PREPARED_ISH_METHODS = %i[
+    exec_prepared
+    async_exec_prepared
+    sync_exec_prepared
+  ].freeze
+
+  EXEC_ISH_METHODS.each do |method|
+    define_method method do |*args|
+      span_name, attrs = span_attrs(:query, *args)
+      tracer.in_span(span_name, attributes: attrs, kind: :client) do
+        super(*args)
+      end
+    end
+  end
+
+  PREPARE_ISH_METHODS.each do |method|
+    define_method method do |*args|
+      span_name, attrs = span_attrs(:prepare, *args)
+      tracer.in_span(span_name, attributes: attrs, kind: :client) do
+        super(*args)
+      end
+    end
+  end
+
+  EXEC_PREPARED_ISH_METHODS.each do |method|
+    define_method method do |*args|
+      span_name, attrs = span_attrs(:execute, *args)
+      tracer.in_span(span_name, attributes: attrs, kind: :client) do
+        super(*args)
+      end
+    end
+  end
+
+  def config
+    EpsagonPostgresInstrumentation.instance.config
+  end
+
+  def tracer
+    EpsagonPostgresInstrumentation.instance.tracer
+  end
+
+  def lru_cache
+    # When SQL is being sanitized, we know that this cache will
+    # never be more than 50 entries * 2000 characters (so, presumably
+    # 100k bytes - or 97k). When not sanitizing SQL, then this cache
+    # could grow much larger - but the small cache size should otherwise
+    # help contain memory growth. The intended use here is to cache
+    # prepared SQL statements, so that we can attach a reasonable
+    # `db.sql.statement` value to spans when those prepared statements
+    # are executed later on.
+    @lru_cache ||= LruCache.new(50)
+  end
+
+  # Rubocop is complaining about 19.31/18 for Metrics/AbcSize.
+  # But, getting that metric in line would force us over the
+  # module size limit! We can't win here unless we want to start
+  # abstracting things into a million pieces.
+  def span_attrs(kind, *args) # rubocop:disable Metrics/AbcSize
+    if kind == :query
+      operation = extract_operation(args[0])
+      sql = args[0]
+    else
+      statement_name = args[0]
+
+      if kind == :prepare
+        sql = args[1]
+        lru_cache[statement_name] = sql
+        operation = 'PREPARE'
+      else
+        sql = lru_cache[statement_name]
+        operation = 'EXECUTE'
+      end
+    end
+
+    attrs = { 'db.operation' => validated_operation(operation), 'db.postgresql.prepared_statement_name' => statement_name }
+    attrs['db.statement'] = sql if config[:epsagon][:metadata_only] == false
+    attrs['db.sql.table'] = table_name(sql)
+    attrs.reject! { |_, v| v.nil? }
+
+    [database_name, client_attributes.merge(attrs)]
+  end
+
+  def table_name(sql)
+    return '' if sql.nil?
+
+    parsed_query = PgQuery.parse(sql)
+    if parsed_query.tables.length == 0
+      ''
+    else
+      parsed_query.tables[0]
+    end
+  rescue PgQuery::ParseError
+    ''
+  end
+
+  def validated_operation(operation)
+    operation if PostgresExtension::SQL_COMMANDS.include?(operation)
+  end
+
+  def extract_operation(sql)
+    # From: https://github.com/open-telemetry/opentelemetry-js-contrib/blob/9244a08a8d014afe26b82b91cf86e407c2599d73/plugins/node/opentelemetry-instrumentation-pg/src/utils.ts#L35
+    sql.to_s.split[0].to_s.upcase
+  end
+
+  def generated_postgres_regex
+    @generated_postgres_regex ||= Regexp.union(PostgresExtension::POSTGRES_COMPONENTS.map { |component| PostgresExtension::COMPONENTS_REGEX_MAP[component] })
+  end
+
+  def database_name
+    conninfo_hash[:dbname]&.to_s
+  end
+
+  def client_attributes
+    attributes = {
+      'db.system' => 'postgresql',
+      'db.user' => conninfo_hash[:user]&.to_s,
+      'db.name' => database_name,
+      'net.peer.name' => conninfo_hash[:host]&.to_s
+    }
+    # attributes['peer.service'] = config[:peer_service] # if config[:peer_service]
+
+    attributes.merge(transport_attrs).reject { |_, v| v.nil? }
+  end
+
+  def transport_attrs
+    if conninfo_hash[:host]&.start_with?('/')
+      { 'net.transport' => 'Unix' }
+    else
+      {
+        'net.transport' => 'IP.TCP',
+        'net.peer.ip' => conninfo_hash[:hostaddr]&.to_s,
+        'net.peer.port' => conninfo_hash[:port]&.to_s
+      }
+    end
+  end
+end
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+# A simple LRU cache for the postgres instrumentation.
+class LruCache
+  # Rather than take a dependency on another gem, we implement a very, very basic
+  # LRU cache here. We can take advantage of the fact that Ruby hashes are ordered
+  # to always keep the recently-accessed keys at the top.
+  def initialize(size)
+    raise ArgumentError, 'Invalid size' if size < 1
+
+    @limit = size
+    @store = {}
+  end
+
+  def [](key)
+    # We need to check for the key explicitly, because `nil` is a valid hash value.
+    return unless @store.key?(key)
+
+    # Since the cache contains the item, we delete and re-insert into the hash.
+    # This guarantees that hash keys are ordered by access recency.
+    value = @store.delete(key)
+    @store[key] = value
+
+    value
+  end
+
+  def []=(key, value)
+    # We remove the value if it's already present, so that the hash keys remain ordered
+    # by access recency.
+    @store.delete(key)
+    @store[key] = value
+    @store.shift if @store.length > @limit
+  end
+end
+
+#
+# EpsagonPostgresInstrumentation
+# Installs the Instrumentation on the PG::Connection class
+#
+class EpsagonPostgresInstrumentation < OpenTelemetry::Instrumentation::Base
+  install do |_config|
+    ::PG::Connection.prepend(PostgresExtension)
+  end
+
+  present do
+    defined?(::PG)
+  end
+end

data/lib/util.rb

@@ -30,4 +30,13 @@ module Util
   		value
   	end
   end
+
+  def self.redis_default_url
+    @@redis_default_url ||= "#{Redis::Client::DEFAULTS[:scheme]}://#{Redis::Client::DEFAULTS[:host]}:#{Redis::Client::DEFAULTS[:port]}/#{Redis::Client::DEFAULTS[:db]}"
+  end
+
+  def self.untraced(&block)
+	  OpenTelemetry::Trace.with_span(OpenTelemetry::Trace::Span.new, &block)
+	end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: epsagon
 version: !ruby/object:Gem::Version
-  version: 0.0.23
+  version: 0.0.28
 platform: ruby
 authors:
 - Epsagon
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-04 00:00:00.000000000 Z
+date: 2021-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -80,32 +80,50 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.11.1
+- !ruby/object:Gem::Dependency
+  name: pg_query
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 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.
 
-  '
+'
 email: info@epsagon.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/arn_parser.rb
 - lib/epsagon.rb
 - lib/epsagon_constants.rb
+- lib/exporter_extension.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/postgres.rb
 - lib/instrumentation/rails.rb
 - lib/instrumentation/sinatra.rb
+- lib/instrumentation/version.rb
 - lib/util.rb
 homepage: https://github.com/epsagon/epsagon-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -120,8 +138,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key:
+rubygems_version: 3.0.3
+signing_key: 
 specification_version: 4
 summary: Epsagon provides tracing to Ruby applications for the collection of distributed
   tracing and performance metrics.