epsagon 0.0.24 → 0.0.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f90417afae2709a9a4dbc88f2edab85cea49ff77577048808401f981cba0a96
-  data.tar.gz: '0811d976ea61bce684d2da4322fb2493b37b58af0c269b1ff785cdede6b5fad2'
+  metadata.gz: 25cf09d9ea5babb3e7caa3380d6b8a78365909391ec3eb84ec150e07fbd9841a
+  data.tar.gz: bb3f2efc49e2b0930ffb677bfb5b8440fa16fe2a41a7adb96b33a35e89efdb67
 SHA512:
-  metadata.gz: 560b2ea93192ed4502f261433728983544f3696378c846df19734602187335f6a155b52bbbaf7c424aca161727b09b37477b7f5a25b2d0711045a9a6c61b40dd
-  data.tar.gz: 5f3a848235508e9adc51555d6ebf2c107dcedde0aba4a0da37d961e37fa143064968cceca46170e9bdd92fc3bcbd8f980f4b7cbf9d7503eb2b77659e98d976fe
+  metadata.gz: b179e2cf5b65329b6a7a40dec43a379fb294ddee0e58f389cd4ffc105f503265ad655cbf50067a9995b04358ddb9d9d0f8441d47e2639befcc4744c8af3c290c
+  data.tar.gz: 5b8443325b4afadffed3f836ba9a7385cbdfbc2cd03eebfee007bb0543ddb5f2b3c279d22a614fa80ecabb7f4a18f6a1292298567d444a84c9a364ef361bb626

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

@@ -12,73 +12,121 @@ require_relative 'instrumentation/net_http'
 require_relative 'instrumentation/faraday'
 require_relative 'instrumentation/aws_sdk'
 require_relative 'instrumentation/rails'
+require_relative 'instrumentation/postgres'
+require_relative 'instrumentation/resque'
 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
+  MUTABLE_CONF_KEYS = Set.new([:metadata_only, :max_attribute_size, :ignore_domains]) 
+
 
-  @@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)
+    validate(get_config)
     OpenTelemetry::SDK.configure
+    @@initialized = true
+  end
+
+  def validate(config)
+    Util.validate_value(config, :metadata_only, 'Must be a boolean') {|v| !!v == v}
+    Util.validate_value(config, :debug, 'Must be a boolean') {|v| !!v == v}
+    Util.validate_value(config, :token, 'Must be a valid Epsagon token') {|v| v.is_a? String and v.size > 10}
+    Util.validate_value(config, :app_name, 'Must be a String') {|v| v.is_a? String}
+    Util.validate_value(config, :max_attribute_size, 'Must be an Integer') {|v| v.is_a? Integer}
+    Util.validate_value(config, :ignore_domains, 'Must be iterable') {|v| v.respond_to?(:each)}
+    Util.validate_value(config, :ignore_domains, 'Must be iterable') {|v| v.respond_to?(:each)}
+  end
+
+  def set_config(**args)
+    unless args.keys.all? {|a| MUTABLE_CONF_KEYS.include?(a)}
+      raise ArgumentError("only #{MUTABLE_CONF_KEYS.to_a} are mutable after `Epsagon.init`")
+    end
+    Epsagon.init unless @@initialized
+    new_conf = get_config.merge(args)
+    validate(new_conf)
+    @@epsagon_config = new_conf
   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', { epsagon: @@epsagon_config }
-
-    if @@epsagon_config[:debug]
-      configurator.add_span_processor OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
-        OpenTelemetry::Exporter::OTLP::Exporter.new(headers: {
-                                                      'x-epsagon-token' => @@epsagon_config[:token]
-                                                    },
-                                                    endpoint: @@epsagon_config[:backend],
-                                                    insecure: @@epsagon_config[:insecure] || false)
-      )
 
+    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 }
+    configurator.use 'EpsagonResqueInstrumentation', { epsagon: get_config }
+
+
+    if get_config[:debug]
       configurator.add_span_processor OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
         OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter.new
       )
-    else
-      configurator.add_span_processor OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
-        exporter: OpenTelemetry::Exporter::OTLP::Exporter.new(headers: {
-                                                                'x-epsagon-token' => @@epsagon_config[:token]
-                                                              },
-                                                              endpoint: @@epsagon_config[:backend],
-                                                              insecure: @@epsagon_config[:insecure] || false)
-      )
     end
+
+    configurator.add_span_processor OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
+      exporter: OpenTelemetry::Exporter::OTLP::Exporter.new(headers: {
+                                                              'x-epsagon-token' => get_config[:token]
+                                                            },
+                                                            endpoint: get_config[:backend],
+                                                            insecure: get_config[:insecure] || false)
+    )
   end
 end
 
@@ -97,16 +145,14 @@ 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 = {
@@ -137,6 +183,7 @@ 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 = {
@@ -148,6 +195,11 @@ module SidekiqServerMiddlewareExtension
         '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'])
@@ -158,11 +210,19 @@ module SidekiqServerMiddlewareExtension
       attributes: attributes,
       with_parent: parent_context,
       kind: :consumer
-    ) do |span|
-      span.add_event('created_at', timestamp: msg['created_at'])
-      span.add_event('enqueued_at', timestamp: msg['enqueued_at'])
-      yield
+    ) 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
 

data/lib/epsagon_constants.rb

@@ -1,3 +1,3 @@
 module EpsagonConstants
-	VERSION = '0.0.24'
+	VERSION = '0.0.29'
 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.rb

@@ -7,6 +7,7 @@ require_relative '../epsagon_constants'
 class EpsagonAwsSdkInstrumentation < OpenTelemetry::Instrumentation::Base
   VERSION = EpsagonConstants::VERSION
   SERVICES = %w[
+    SecretsManager
     ACM
     APIGateway
     AppStream

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'opentelemetry/trace/status'
+require 'action_controller/railtie'
 
 module QueueTime
   REQUEST_START = 'HTTP_X_REQUEST_START'
@@ -130,7 +131,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 +190,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)
@@ -284,3 +285,48 @@ class EpsagonRailtie < ::Rails::Railtie
     )
   end
 end
+
+module RackExtension
+  module_function
+
+  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

data/lib/instrumentation/epsagon_resque_job.rb

@@ -0,0 +1,113 @@
+require 'json'
+
+module EpsagonResqueModule
+  def self.prepended(base)
+    class << base
+      prepend ClassMethods
+    end
+  end
+
+  # Module to prepend to Resque singleton class
+  module ClassMethods
+    def push(queue, item)
+      epsagon_conf = config[:epsagon] || {}
+      # Check if the job is being wrapped by ActiveJob
+      # before retrieving the job class name
+      job_class = if item[:class] == 'ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper' && item[:args][0]&.is_a?(Hash)
+                    item[:args][0]['job_class']
+                  else
+                    item[:class]
+                  end
+      attributes = {
+        'operation' => 'enqueue',
+        'messaging.system' => 'resque',
+        'messaging.resque.job_class' => job_class,
+        'messaging.destination' => queue.to_s,
+        'messaging.destination_kind' => 'queue',
+        'messaging.resque.redis_url' => Resque.redis.connection[:id]
+      }
+      unless epsagon_conf[:metadata_only]
+        attributes.merge!({
+          'messaging.resque.args' => JSON.dump(item)
+        })
+      end
+
+      tracer.in_span(queue.to_s, attributes: attributes, kind: :producer) do
+        OpenTelemetry.propagation.text.inject(item)
+        super
+      end
+    end
+
+    def tracer
+      EpsagonResqueInstrumentation.instance.tracer
+    end
+
+    def config
+      EpsagonResqueInstrumentation.instance.config
+    end
+  end
+end
+
+module EpsagonResqueJob
+  def perform # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    inner_exception = nil
+    epsagon_conf = config[:epsagon] || {}
+    job_args = args || []
+
+    # Check if the job is being wrapped by ActiveJob
+    # before retrieving the job class name
+    job_class = if payload_class_name == 'ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper' && job_args[0]&.is_a?(Hash)
+                  job_args[0]['job_class']
+                else
+                  payload_class_name
+                end
+
+    attributes = {
+        'operation' => 'perform',
+        'messaging.system' => 'resque',
+        'messaging.resque.job_class' => job_class,
+        'messaging.destination' => queue.to_s,
+        'messaging.destination_kind' => 'queue',
+        'messaging.resque.redis_url' => Resque.redis.connection[:id]
+    }
+    runner_attributes = {
+      'type' => 'resque_worker',
+      'messaging.resque.redis_url' => Resque.redis.connection[:id],
+
+    }
+
+    extracted_context = OpenTelemetry.propagation.text.extract(@payload)
+
+    unless epsagon_conf[:metadata_only]
+      attributes.merge!({
+        'messaging.resque.args' => JSON.dump(args)
+      })
+    end
+    tracer.in_span(
+      queue.to_s,
+      attributes: attributes,
+      with_parent: extracted_context,
+      kind: :consumer
+    ) do |trigger_span|
+      tracer.in_span(job_class,
+        attributes: runner_attributes,
+        kind: :consumer
+      ) do |runner_span|
+        super
+      end
+    rescue Exception => e
+      inner_exception = e
+    end
+    raise inner_exception if inner_exception
+  end
+
+  private
+
+  def tracer
+    EpsagonResqueInstrumentation.instance.tracer
+  end
+
+  def config
+    EpsagonResqueInstrumentation.instance.config
+  end
+end

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/instrumentation/rails.rb

@@ -1,58 +1,11 @@
 # frozen_string_literal: true
 
 require 'opentelemetry'
-require 'rails'
-require 'action_controller/railtie'
 
 require_relative '../util'
 require_relative '../epsagon_constants'
 
 
-module RackExtension
-  module_function
-
-  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'

data/lib/instrumentation/resque.rb

@@ -0,0 +1,21 @@
+class EpsagonResqueInstrumentation < OpenTelemetry::Instrumentation::Base
+  install do |_config|
+    require_dependencies
+    patch
+  end
+
+  present do
+    defined?(::Resque)
+  end
+
+  private
+
+  def patch
+    ::Resque.prepend(EpsagonResqueModule)
+    ::Resque::Job.prepend(EpsagonResqueJob)
+  end
+
+  def require_dependencies
+    require_relative 'epsagon_resque_job'
+  end
+end

data/lib/util.rb

@@ -4,6 +4,10 @@ require 'cgi'
 
 # Utilities for epsagon opentelemetry solution
 module Util
+  def self.validate_value(h, k, message, &block)
+    raise ArgumentError.new( "#{k} #{message}. Got #{h[k].class}: #{h[k]}" ) unless yield(h[k])
+  end
+
   def self.epsagon_query_attributes(query_string)
     if query_string&.include? '='
       { 'http.request.query_params' => CGI.parse(query_string).to_json }
@@ -25,7 +29,7 @@ module Util
   		end
   		return value
   	elsif value.instance_of? String then
-  		value[0, max_size]
+  		(value.frozen? ? value.dup : value).force_encoding('utf-8')[0, max_size]
   	else
   		value
   	end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: epsagon
 version: !ruby/object:Gem::Version
-  version: 0.0.24
+  version: 0.0.29
 platform: ruby
 authors:
 - Epsagon
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-12 00:00:00.000000000 Z
+date: 2021-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -80,6 +80,20 @@ 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.
@@ -90,15 +104,20 @@ 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/epsagon_resque_job.rb
 - lib/instrumentation/faraday.rb
 - lib/instrumentation/net_http.rb
+- lib/instrumentation/postgres.rb
 - lib/instrumentation/rails.rb
+- lib/instrumentation/resque.rb
 - lib/instrumentation/sinatra.rb
 - lib/instrumentation/version.rb
 - lib/util.rb