epsagon 0.0.27 → 0.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74f7a24306d3840c295345b485169ffa8bb4bfa2285f7d43ae69440d0b685e53
-  data.tar.gz: e043b98f22a6d804fc5692b8ab60c8eb1e05d74de736412fdfef58179afce086
+  metadata.gz: 1a17b55f2ce2ff35ca70dd51e8f8337041e202c528b6c691800d3e3b7b0d42c4
+  data.tar.gz: d93046c571faa2d35a681217cb12952c57c7bd3232e77a136a5954a5534541b1
 SHA512:
-  metadata.gz: bb53cf200be779ba464a58a41bc62d03849ec8be6e161fca6a8d1f8594b124d38c3445155ac3e2582a318dc513415e6a236fd43f9a75b782f9642a29d5795c71
-  data.tar.gz: de6b92f478e04c362911160c29eec775553ef16f3714b9f6b78c062d60ee46161291b08d89f254f8bdf0f0d80884e4e41a79146114d87fc84ef758f246710c04
+  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

@@ -12,23 +12,30 @@ 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']
+  DEFAULT_IGNORE_DOMAINS = ['newrelic.com'].freeze
 
-  @@epsagon_config = {}
+  @@epsagon_config = nil
 
   module_function
 
   def init(**args)
-    @@epsagon_config = {
+    get_config.merge!(args)
+    OpenTelemetry::SDK.configure
+  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'] || '',
@@ -37,52 +44,69 @@ module Epsagon
       backend: ENV['EPSAGON_BACKEND'] || DEFAULT_BACKEND,
       ignore_domains: ENV['EPSAGON_IGNORE_DOMAINS'] || DEFAULT_IGNORE_DOMAINS
     }
-    @@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 }
+
+    if get_config[:debug]
+      configurator.add_span_processor OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
+        OpenTelemetry::Exporter::OTLP::Exporter.new(headers: {
+                                                      'x-epsagon-token' => get_config[:token]
+                                                    },
+                                                    endpoint: get_config[:backend],
+                                                    insecure: get_config[:insecure] || false)
+      )
+
       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' => get_config[:token]
+                                                              },
+                                                              endpoint: get_config[:backend],
+                                                              insecure: get_config[:insecure] || false)
+      )
     end
-
-    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
 end
 

data/lib/epsagon_constants.rb

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

data/lib/instrumentation/epsagon_rails_middleware.rb

@@ -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/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

@@ -4,10 +4,6 @@ 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 }
@@ -29,7 +25,7 @@ module Util
   		end
   		return value
   	elsif value.instance_of? String then
-  		(value.frozen? ? value.dup : value).force_encoding('utf-8')[0, max_size]
+  		value[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.27
+  version: 0.0.28
 platform: ruby
 authors:
 - Epsagon
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-08 00:00:00.000000000 Z
+date: 2021-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -80,16 +80,31 @@ 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
@@ -99,6 +114,7 @@ files:
 - 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
@@ -107,7 +123,7 @@ homepage: https://github.com/epsagon/epsagon-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -122,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.