instana 1.195.1 → 1.197.0.pre2

data/lib/instana/backend/serverless_agent.rb

@@ -0,0 +1,118 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Backend
+    # @since 1.197.0
+    class ServerlessAgent
+      DEFAULT_SECRETS = 'contains-ignore-case:key,password,secret'.freeze
+      attr_reader :timer
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(snapshots,
+                     timer_class: Concurrent::TimerTask,
+                     processor: ::Instana.processor,
+                     logger: ::Instana.logger,
+                     backend_uri: ENV['INSTANA_ENDPOINT_URL'],
+                     secrets: ENV.fetch('INSTANA_SECRETS', DEFAULT_SECRETS), headers: ENV.fetch('INSTANA_EXTRA_HTTP_HEADERS', ''))
+        @snapshots = snapshots
+        @processor = processor
+        @logger = logger
+        @timer = timer_class.new(execution_interval: 1, run_now: true) { send_bundle }
+        @backend_uri = URI(backend_uri)
+        @client = Backend::RequestClient.new(@backend_uri.host, @backend_uri.port, use_ssl: @backend_uri.scheme == "https")
+        @secrets = secrets
+        @headers = headers
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def setup; end
+
+      def spawn_background_thread
+        @timer.execute
+      end
+
+      # @return [Boolean] true if the agent able to send spans to the backend
+      def ready?
+        true
+      end
+
+      # @return [Hash, NilClass] the backend friendly description of the current in process collector
+      def source
+        return @source if @source
+
+        snapshot = @snapshots.detect { |s| s.respond_to?(:source) }
+
+        if snapshot
+          @source = snapshot.source
+        else
+          @logger.warn('Unable to find a snapshot which provides a source.')
+          {}
+        end
+      end
+
+      # @return [Array] extra headers to include in the trace
+      def extra_headers
+        @headers.split(';')
+      end
+
+      # @return [Hash] values which are removed from urls sent to the backend
+      def secret_values
+        # TODO: Parse from env
+        matcher, *keys = @secrets.split(/[:,]/)
+        {'matcher' => matcher, 'list' => keys}
+      end
+
+      private
+
+      def request_headers
+        {
+          'X-Instana-Host' => host_name,
+          'X-Instana-Key' => ENV['INSTANA_AGENT_KEY'],
+          'X-Instana-Time' => (Time.now.to_i * 1000).to_s
+        }
+      end
+
+      def send_bundle
+        spans = @processor.queued_spans
+        bundle = {
+          spans: spans,
+          metrics: {
+            plugins: agent_snapshots
+          }
+        }
+
+        path = "#{@backend_uri.path}/bundle"
+        response = @client.send_request('POST', path, bundle, request_headers)
+
+        return if response.ok?
+
+        @logger.warn("Recived a `#{response.code}` when sending data.")
+      end
+
+      def agent_snapshots
+        @snapshots.map do |snapshot|
+          begin # rubocop:disable Style/RedundantBegin, Lint/RedundantCopDisableDirective
+            snapshot.snapshot
+          rescue StandardError => e
+            @logger.error(e.message)
+            nil
+          end
+        end.compact
+      end
+
+      def host_name
+        return @host_name if @host_name
+
+        snapshot = @snapshots.detect { |s| s.respond_to?(:host_name) }
+
+        if snapshot
+          @host_name = snapshot.host_name
+        else
+          @logger.warn('Unable to find a snapshot which provides a host_name.')
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/instana/base.rb

@@ -4,16 +4,13 @@
 require "logger"
 require "instana/version"
 require "instana/util"
-require "instana/helpers"
 
 module Instana
   class << self
     attr_accessor :agent
-    attr_accessor :collector
     attr_accessor :tracer
     attr_accessor :processor
     attr_accessor :config
-    attr_accessor :logger
     attr_accessor :pid
     attr_reader :secrets
 
@@ -24,36 +21,20 @@ module Instana
     # to run" state.
     #
     def setup
-      @agent  = ::Instana::Agent.new
+      @agent  = ::Instana::Backend::Agent.new
       @tracer = ::Instana::Tracer.new
       @processor = ::Instana::Processor.new
-      @collector = ::Instana::Collector.new
       @secrets = ::Instana::Secrets.new
     end
-  end
-end
-
-# Setup the logger as early as possible
-
-# Default Logger outputs to STDOUT
-::Instana.logger = Logger.new(STDOUT)
-
-# Can instead log to a file that is rotated every 10M
-# ::Instana.logger = Logger.new("instana.log", 10, 1073741824)
 
-if ENV.key?('INSTANA_GEM_TEST')
-  ::Instana.logger.level = Logger::DEBUG
-elsif ENV.key?('INSTANA_GEM_DEV') || ENV.key?('INSTANA_DEBUG')
-  ::Instana.logger.level = Logger::DEBUG
-elsif ENV.key?('INSTANA_QUIET')
-  ::Instana.logger.level = Logger::FATAL
-else
-  ::Instana.logger.level = Logger::WARN
-end
+    def logger
+      @logger ||= ::Instana::LoggerDelegator.new(Logger.new(STDOUT))
+    end
 
-::Instana.logger.formatter = proc do |severity, datetime, progname, msg|
-  "#{datetime}: #{severity.rjust(5)} Instana: #{progname} #{msg}\n"
+    def logger=(val)
+      @logger.__setobj__(val)
+    end
+  end
 end
 
-
 ::Instana.logger.info "Stan is on the scene.  Starting Instana instrumentation version #{::Instana::VERSION}"

data/lib/instana/config.rb

@@ -3,26 +3,21 @@
 
 module Instana
   class Config
-
-    def initialize
+    def initialize(logger: ::Instana.logger, agent_host: ENV['INSTANA_AGENT_HOST'], agent_port: ENV['INSTANA_AGENT_PORT'])
       @config = {}
-      if ENV.key?('INSTANA_AGENT_HOST')
-        ::Instana.logger.debug "Using custom agent host location specified in INSTANA_AGENT_HOST (#{ENV['INSTANA_AGENT_HOST']})"
-        @config[:agent_host] = ENV['INSTANA_AGENT_HOST']
+      if agent_host
+        logger.debug "Using custom agent host location specified in INSTANA_AGENT_HOST (#{ENV['INSTANA_AGENT_HOST']})"
+        @config[:agent_host] = agent_host
       else
         @config[:agent_host] = '127.0.0.1'
       end
-      if ENV.key?('INSTANA_AGENT_PORT')
-        ::Instana.logger.debug "Using custom agent port specified in INSTANA_AGENT_PORT (#{ENV['INSTANA_AGENT_PORT']})"
-        @config[:agent_port] = ENV['INSTANA_AGENT_PORT']
+      if agent_port
+        logger.debug "Using custom agent port specified in INSTANA_AGENT_PORT (#{ENV['INSTANA_AGENT_PORT']})"
+        @config[:agent_port] = agent_port
       else
         @config[:agent_port] = 42699
       end
 
-      # This option has been DEPRECATED. Use the INSTANA_DISABLE environment variable instead.
-      # https://docs.instana.io/ecosystem/ruby/configuration/
-      @config[:enabled] = true
-
       # Enable/disable metrics globally or individually (default: all enabled)
       @config[:metrics] = { :enabled => true }
       @config[:metrics][:gc]     = { :enabled => true }
@@ -56,7 +51,7 @@ module Instana
       @config[:sanitize_sql] = true
 
       # W3 Trace Context Support
-      @config[:w3_trace_correlation] = ENV.fetch('INSTANA_W3C_TRACE_CORRELATION', 'true').eql?('true')
+      @config[:w3_trace_correlation] = ENV['INSTANA_DISABLE_W3C_TRACE_CORRELATION'].nil?
 
       @config[:action_controller]  = { :enabled => true }
       @config[:action_view]        = { :enabled => true }
@@ -80,15 +75,6 @@ module Instana
 
     def []=(key, value)
       @config[key.to_sym] = value
-
-      if key == :enabled
-        # Configuring global enable/disable flag, then set the
-        # appropriate children flags.
-        @config[:metrics][:enabled] = value
-        @config[:tracing][:enabled] = value
-
-        ::Instana.logger.warn "::Instana.config[:enabled] has been deprecated.  Set INSTANA_DISABLE environment variable to any value instead."
-      end
     end
   end
 end

data/lib/instana/instrumentation/aws_sdk_dynamodb.rb

@@ -7,11 +7,11 @@ module Instana
       class Handler < Seahorse::Client::Handler
         def call(context)
           dynamo_tags = {
-            op: context.operation_name,
+            op: format_operation(context.operation_name),
             table: table_name_from(context)
           }
 
-          ::Instana.tracer.trace(:dynamodb, dynamo_tags) { @handler.call(context) }
+          ::Instana.tracer.trace(:dynamodb, {dynamodb: dynamo_tags}) { @handler.call(context) }
         end
 
         private
@@ -19,6 +19,25 @@ module Instana
         def table_name_from(context)
           context.params[:table_name] || context.params[:global_table_name] || 'Unknown'
         end
+
+        def format_operation(name)
+          case name
+          when :create_table
+            'create'
+          when :list_tables
+            'list'
+          when :get_item
+            'get'
+          when :put_item
+            'put'
+          when :update_item
+            'update'
+          when :delete_item
+            'delete'
+          else
+            name.to_s
+          end
+        end
       end
 
       def add_handlers(handlers, _config)

data/lib/instana/instrumentation/aws_sdk_s3.rb

@@ -0,0 +1,55 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Instrumentation
+    class S3 < Seahorse::Client::Plugin
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          s3_tags = {
+            op: format_operation(context.operation_name),
+            bucket: bucket_name_from(context),
+            key: key_from_context(context)
+          }.compact
+
+          ::Instana.tracer.trace(:s3, {s3: s3_tags}) { @handler.call(context) }
+        end
+
+        private
+
+        def bucket_name_from(context)
+          context.params[:bucket] || 'Unknown'
+        end
+
+        def key_from_context(context)
+          context.params[:key]
+        end
+
+        def format_operation(name)
+          case name
+          when :create_bucket
+            'createBucket'
+          when :delete_bucket
+            'deleteBucket'
+          when :delete_object
+            'delete'
+          when :get_object
+            'get'
+          when :head_object
+            'metadata'
+          when :list_objects
+            'list'
+          when :put_object
+            'list'
+          else
+            name.to_s
+          end
+        end
+      end
+
+      def add_handlers(handlers, _config)
+        handlers.add(Handler, step: :initialize)
+      end
+    end
+  end
+end

data/lib/instana/instrumentation/aws_sdk_sns.rb

@@ -0,0 +1,29 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Instrumentation
+    class SNS < Seahorse::Client::Plugin
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          sns_tags = {
+            topic: context.params[:topic_arn],
+            target: context.params[:target_arn],
+            phone: context.params[:phone_number],
+            subject: context.params[:subject]
+          }.compact
+
+          if context.operation_name == :publish
+            ::Instana.tracer.trace(:sns, {sns: sns_tags}) { @handler.call(context) }
+          else
+            @handler.call(context)
+          end
+        end
+      end
+
+      def add_handlers(handlers, _config)
+        handlers.add(Handler, step: :initialize)
+      end
+    end
+  end
+end

data/lib/instana/instrumentation/aws_sdk_sqs.rb

@@ -0,0 +1,98 @@
+# (c) Copyright IBM Corp. 2021
+# (c) Copyright Instana Inc. 2021
+
+module Instana
+  module Instrumentation
+    class SQS < Seahorse::Client::Plugin
+      class Handler < Seahorse::Client::Handler
+        SPAN_FORMING_OPERATIONS = [:send_message, :send_message_batch, :get_queue_url, :create_queue, :delete_message, :delete_message_batch].freeze
+
+        def call(context)
+          is_tracing = ::Instana.tracer.tracing?
+          unless is_tracing && SPAN_FORMING_OPERATIONS.include?(context.operation_name)
+            return @handler.call(context)
+          end
+
+          span_tags = tags_for(context.operation_name, context.params).compact
+
+          ::Instana.tracer.trace(:sqs, {sqs: span_tags}) do |span|
+            case context.operation_name
+            when :send_message
+              inject_instana_headers(span, context.params)
+            when :send_message_batch
+              context.params[:entries].each { |e| inject_instana_headers(span, e) }
+            end
+
+            response = @handler.call(context)
+
+            span_tags[:queue] = response.queue_url if response.respond_to?(:queue_url)
+            span.set_tags(sqs: span_tags)
+
+            response
+          end
+        end
+
+        private
+
+        def inject_instana_headers(span, params)
+          params[:message_attributes] ||= {}
+          params[:message_attributes].merge!({
+                                               "X_INSTANA_T" => {data_type: 'String', string_value: span.context.trace_id},
+                                               "X_INSTANA_S" => {data_type: 'String', string_value: span.context.span_id},
+                                               "X_INSTANA_L" => {data_type: 'String', string_value: span.context.level.to_s}
+                                             })
+        end
+
+        def tags_for(operation_name, params)
+          case operation_name
+          when :create_queue
+            {
+              sort: 'exit',
+              type: 'create.queue',
+              queue: params[:queue_name]
+            }
+          when :get_queue_url
+            {
+              sort: 'exit',
+              type: 'get.queue',
+              queue: params[:queue_name]
+            }
+          when :send_message
+            {
+              sort: 'exit',
+              type: 'single.sync',
+              queue: params[:queue_url],
+              group: params[:message_group_id]
+            }
+          when :send_message_batch
+            {
+              sort: 'exit',
+              type: 'single.sync',
+              queue: params[:queue_url],
+              size: params[:entries].count
+            }
+          when :delete_message
+            {
+              sort: 'exit',
+              type: 'delete.single.sync',
+              queue: params[:queue_url]
+            }
+          when :delete_message_batch
+            {
+              sort: 'exit',
+              type: 'delete.batch.sync',
+              queue: params[:queue_url],
+              size: params[:entries].count
+            }
+          else
+            {}
+          end
+        end
+      end
+
+      def add_handlers(handlers, _config)
+        handlers.add(Handler, step: :initialize)
+      end
+    end
+  end
+end