epsagon 0.0.27 → 0.0.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74f7a24306d3840c295345b485169ffa8bb4bfa2285f7d43ae69440d0b685e53
-  data.tar.gz: e043b98f22a6d804fc5692b8ab60c8eb1e05d74de736412fdfef58179afce086
+  metadata.gz: d478fc58c432f30f98f666ae27e27b31bca3fd88254d0ef5b108b6d52a21d715
+  data.tar.gz: d535f30b5a159895c985ef0da98f1e1ea2c433db3f4163805fb5b3d6c7e1fa82
 SHA512:
-  metadata.gz: bb53cf200be779ba464a58a41bc62d03849ec8be6e161fca6a8d1f8594b124d38c3445155ac3e2582a318dc513415e6a236fd43f9a75b782f9642a29d5795c71
-  data.tar.gz: de6b92f478e04c362911160c29eec775553ef16f3714b9f6b78c062d60ee46161291b08d89f254f8bdf0f0d80884e4e41a79146114d87fc84ef758f246710c04
+  metadata.gz: 021e018a393a88cefb02c31ba2ee66fb5ec5f367b468ab1ed2b6537ba7e951ee3ccad40535ceed66b498589fbc1c5190cfac31f69a439a40afbc99547bbe4506
+  data.tar.gz: 0fc691d485e757bc0314acc6ef5901ea39a676da2725bed92700f2260b6f37e48025c5b25c2f9a0a18f46fb35cd175c11bb2843fabeb1dc960b7dd1367f79e2c

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,65 +12,117 @@ 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']
+  DEFAULT_IGNORE_DOMAINS = ['newrelic.com'].freeze
+  MUTABLE_CONF_KEYS = Set.new([:metadata_only, :max_attribute_size, :ignore_domains, :ignored_keys]) 
 
-  @@epsagon_config = {}
+  @@epsagon_config = nil
 
   module_function
 
   def init(**args)
-    @@epsagon_config = {
+    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) && (v.size > 10) }
+    Util.validate_value(config, :app_name, 'Must be a String') {|v| (v.is_a? String) && (v.size > 0) }
+    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, :ignored_keys, '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.new("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 add_ignored_key(key)
+    get_config[:ignored_keys].push(key).uniq
+  end
+
+  def remove_ignored_key(key)
+    get_config[:ignored_keys].delete(key)
+  end
+
+  def get_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
+      ignore_domains: ENV['EPSAGON_IGNORE_DOMAINS']&.split(',') || DEFAULT_IGNORE_DOMAINS,
+      ignored_keys: ENV['EPSAGON_IGNORED_KEYS']&.split(',') || []
     }
-    @@epsagon_config.merge!(args)
+  end
 
-    Util.validate_value(@@epsagon_config, :metadata_only, 'Must be a boolean') {|v| !!v == v}
-    Util.validate_value(@@epsagon_config, :debug, 'Must be a boolean') {|v| !!v == v}
-    Util.validate_value(@@epsagon_config, :token, 'Must be a valid Epsagon token') {|v| v.is_a? String and v.size > 10}
-    Util.validate_value(@@epsagon_config, :app_name, 'Must be a String') {|v| v.is_a? String}
-    Util.validate_value(@@epsagon_config, :max_attribute_size, 'Must be an Integer') {|v| v.is_a? Integer}
-    Util.validate_value(@@epsagon_config, :ignore_domains, 'Must be iterable') {|v| v.respond_to?(:each)}
+  def set_ecs_metadata
+    metadata_uri = ENV['ECS_CONTAINER_METADATA_URI']
+    return {} if metadata_uri.nil?
 
-    OpenTelemetry::SDK.configure
-  end
+    response = Net::HTTP.get(URI(metadata_uri))
+    ecs_metadata = JSON.parse(response)
+    arn = Arn.parse(ecs_metadata['Labels']['com.amazonaws.ecs.task-arn'])
 
-  def get_config
-    @@epsagon_config
+    {
+      '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,
-        'epsagon.metadata_only' => @@epsagon_config[:metadata_only]
-      })
+      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.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
       )
@@ -78,10 +130,10 @@ module Epsagon
 
     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
@@ -91,10 +143,15 @@ module SpanExtension
 
   BLANKS = [nil, [], '']
 
+  def set_mapping_attribute(key, value)
+    value = Util.prepare_attr(key, value, Epsagon.get_config[:max_attribute_size], Epsagon.get_config[:ignored_keys])
+    set_attribute(key, value) if value
+  end
+
   def set_attribute(key, value)
     unless BLANKS.include?(value)
-      value = Util.trim_attr(value, Epsagon.get_config[:max_attribute_size])
-      super(key, value)
+      value = Util.prepare_attr(key, value, Epsagon.get_config[:max_attribute_size], Epsagon.get_config[:ignored_keys])
+      super(key, value) if value
     end
   end
 
@@ -102,8 +159,9 @@ module SpanExtension
     super(*args)
     if @attributes
       @attributes = Hash[@attributes.select {|k,v| not BLANKS.include? v}.map { |k,v|
-        [k, Util.trim_attr(v, Epsagon.get_config[:max_attribute_size])]
-      }]
+        v = Util.prepare_attr(k, v, Epsagon.get_config[:max_attribute_size], Epsagon.get_config[:ignored_keys])
+        [k, v] if v
+      }.compact]
     end
   end
 end

data/lib/epsagon_constants.rb

@@ -1,3 +1,3 @@
 module EpsagonConstants
-	VERSION = '0.0.27'
+	VERSION = '0.0.31'
 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

@@ -59,10 +59,10 @@ class EpsagonAwsHandler < Seahorse::Client::Handler
               'message_body' => m[:message_body],
             } 
           end
-          attributes['aws.sqs.record'] = JSON.dump(messages_attributes) if messages_attributes
+          attributes['aws.sqs.record'] = 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]
+        attributes['aws.sqs.record.message_attributes'] = context.params[:message_attributes] if context.params[:message_attributes]
       end
     elsif attributes['aws.service'] == 'sns'
       topic_arn = context.params[:topic_arn]
@@ -71,7 +71,7 @@ class EpsagonAwsHandler < Seahorse::Client::Handler
       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]
+        attributes['aws.sns.message_attributes'] = context.params[:message_attributes] if context.params[:message_attributes]
       end
     end
     tracer.in_span(span_name, kind: span_kind, attributes: attributes) do |span|
@@ -105,7 +105,7 @@ class EpsagonAwsHandler < Seahorse::Client::Handler
                 end
                 record
               end
-              span.set_attribute('aws.sqs.record', JSON.dump(messages_attributes)) if messages_attributes
+              span.set_mapping_attribute('aws.sqs.record', messages_attributes) if messages_attributes
             end
             if context.operation.name == 'ReceiveMessage'
               messages_attributes = result.messages.map do |m|
@@ -123,7 +123,7 @@ class EpsagonAwsHandler < Seahorse::Client::Handler
                 end 
                 record
               end
-              span.set_attribute('aws.sqs.record', JSON.dump(messages_attributes)) if messages_attributes
+              span.set_mapping_attribute('aws.sqs.record', 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'

data/lib/instrumentation/epsagon_faraday_middleware.rb

@@ -38,7 +38,7 @@ class EpsagonFaradayMiddleware < ::Faraday::Middleware
       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.headers' => Hash[env.request_headers],
         'http.request.body' => env.body,
         'http.request.headers.User-Agent' => env.request_headers['User-Agent']
       })
@@ -67,7 +67,7 @@ class EpsagonFaradayMiddleware < ::Faraday::Middleware
     span.set_attribute('http.status_code', response.status)
 
     unless config[:epsagon][:metadata_only]
-      span.set_attribute('http.response.headers', response.headers.to_json)
+      span.set_attribute('http.response.headers', Hash[env.response.headers])
       span.set_attribute('http.response.body', response.body)
     end
     span.status = OpenTelemetry::Trace::Status.http_to_status(

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'
@@ -75,11 +76,9 @@ class EpsagonRackMiddleware
 
   def call(env)
     original_env = env.dup
-    extracted_context = OpenTelemetry.propagation.http.extract(env)
-    frontend_context = create_frontend_span(env, extracted_context)
 
     # restore extracted context in this process:
-    OpenTelemetry::Context.with_current(frontend_context || extracted_context) do
+    OpenTelemetry::Context.with_current(OpenTelemetry.propagation.http.extract(env)) do
       request_span_name = create_request_span_name(env['REQUEST_URI'] || original_env['PATH_INFO'])
       tracer.in_span(env['HTTP_HOST'] || 'unknown',
                      attributes: request_span_attributes(env: env),
@@ -97,28 +96,10 @@ class EpsagonRackMiddleware
         end
       end
     end
-  ensure
-    finish_span(frontend_context)
   end
 
   private
 
-  # return Context with the frontend span as the current span
-  def create_frontend_span(env, extracted_context)
-    request_start_time = QueueTime.get_request_start(env)
-
-    return unless config[:record_frontend_span] && !request_start_time.nil?
-
-    span = tracer.start_span('http_server.proxy',
-                             with_parent: extracted_context,
-                             attributes: {
-                               'start_time' => request_start_time.to_f
-                             },
-                             kind: :server)
-
-    OpenTelemetry::Trace.context_with_span(span, parent_context: extracted_context)
-  end
-
   def finish_span(context)
     OpenTelemetry::Trace.current_span(context).finish if context
   end
@@ -189,7 +170,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 +265,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' => 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' => 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

@@ -34,7 +34,7 @@ module EpsagonNetHTTPExtension
       attributes.merge!({
                           'http.request.path_params' => path_params,
                           'http.request.body' => body,
-                          'http.request.headers' => headers.to_json,
+                          'http.request.headers' => Hash[headers],
                           'http.request.headers.User-Agent' => headers['user-agent']
                         })
       attributes.merge!(Util.epsagon_query_attributes(query))
@@ -62,7 +62,7 @@ module EpsagonNetHTTPExtension
 
     span.set_attribute('http.status_code', status_code)
     unless config[:epsagon][:metadata_only]
-      span.set_attribute('http.response.headers', Hash[response.each_header.to_a].to_json)
+      span.set_attribute('http.response.headers', Hash[response.each_header.to_a])
       span.set_attribute('http.response.body', response.body)
     end
     span.status = OpenTelemetry::Trace::Status.http_to_status(

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

@@ -16,6 +16,30 @@ module Util
     end
   end
 
+
+  def self.remove_key_recursive(h, key) 
+    dot_idx = key.index('.')
+    if not dot_idx.nil?
+      next_hash = h[key[0..dot_idx - 1]]
+      self.remove_key_recursive(next_hash, key[dot_idx + 1..-1]) if next_hash
+    else
+      h.delete(key)
+    end
+  end
+
+  def self.prepare_attr(key, value, max_size, excluded_keys)
+    return nil if excluded_keys.include? key
+    return self.trim_attr(value, max_size) unless value.instance_of? Hash
+    value = value.dup
+    excluded_keys.each do |ekey|
+      if ekey.start_with? (key + '.')
+        rest_of_key = ekey[key.size + 1..-1]
+        self.remove_key_recursive(value, rest_of_key)
+      end
+    end
+    return self.trim_attr(JSON.dump(value), max_size)
+  end
+
   def self.trim_attr(value, max_size)
   	if value.instance_of? Array then 
   		current_size = 2

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: epsagon
 version: !ruby/object:Gem::Version
-  version: 0.0.27
+  version: 0.0.31
 platform: ruby
 authors:
 - Epsagon
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-08 00:00:00.000000000 Z
+date: 2021-08-31 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,6 +104,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/arn_parser.rb
 - lib/epsagon.rb
 - lib/epsagon_constants.rb
 - lib/exporter_extension.rb
@@ -97,9 +112,12 @@ files:
 - 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