instana 1.217.1 → 2.1.0

data/lib/instana/instrumentation/sidekiq-worker.rb

@@ -5,11 +5,11 @@ module Instana
   module Instrumentation
     class SidekiqWorker
       def call(_worker, msg, _queue)
-        kv_payload = { :'sidekiq-worker' => {} }
-        kv_payload[:'sidekiq-worker'][:job_id] = msg['jid']
-        kv_payload[:'sidekiq-worker'][:queue] = msg['queue']
-        kv_payload[:'sidekiq-worker'][:job] = msg['class'].to_s
-        kv_payload[:'sidekiq-worker'][:retry] = msg['retry'].to_s
+        kvs = { :'sidekiq-worker' => {} }
+        kvs[:'sidekiq-worker'][:job_id] = msg['jid']
+        kvs[:'sidekiq-worker'][:queue] = msg['queue']
+        kvs[:'sidekiq-worker'][:job] = msg['class'].to_s
+        kvs[:'sidekiq-worker'][:retry] = msg['retry'].to_s
 
         # Temporary until we move connection collection to redis
         # instrumentation
@@ -24,29 +24,30 @@ module Instana
                        else # Unexpected version, continue without recording any redis-url
                          break
                        end
-          kv_payload[:'sidekiq-worker'][:'redis-url'] = "#{host}:#{port}"
+          kvs[:'sidekiq-worker'][:'redis-url'] = "#{host}:#{port}"
         end
 
-        context = {}
+        trace_context = nil
         if msg.key?('X-Instana-T')
           trace_id = msg.delete('X-Instana-T')
           span_id = msg.delete('X-Instana-S')
-          context[:trace_id] = ::Instana::Util.header_to_id(trace_id)
-          context[:span_id] = ::Instana::Util.header_to_id(span_id) if span_id
+          trace_context = ::Instana::SpanContext.new(
+            trace_id: ::Instana::Util.header_to_id(trace_id),
+            span_id: span_id ? ::Instana::Util.header_to_id(span_id) : nil
+          )
         end
 
-        ::Instana.tracer.log_start_or_continue(
-          :'sidekiq-worker', kv_payload, context
-        )
-
-        yield
-      rescue => e
-        kv_payload[:'sidekiq-worker'][:error] = true
-        ::Instana.tracer.log_info(kv_payload)
-        ::Instana.tracer.log_error(e)
-        raise
-      ensure
-        ::Instana.tracer.log_end(:'sidekiq-worker', {}) if ::Instana.tracer.tracing?
+        parent_non_recording_span = OpenTelemetry::Trace.non_recording_span(trace_context) if trace_context
+        Trace.with_span(parent_non_recording_span) do
+          Instana.tracer.in_span(:'sidekiq-worker', attributes: kvs) do |span|
+            yield
+          rescue => e
+            kvs[:'sidekiq-worker'][:error] = true
+            span.set_tags(kvs)
+            span.record_exception(e)
+            raise
+          end
+        end
       end
     end
   end

data/lib/instana/instrumented_logger.rb

@@ -17,7 +17,7 @@ module Instana
           level: LEVEL_LABELS[severity],
           message: "#{message} #{progname}".strip
         }
-        Instana::Tracer.trace(:log, {log: tags}) {}
+        Instana.tracer.in_span(:log, attributes: {log: tags}) {}
       end
 
       super(severity, message, progname)

data/lib/instana/samplers/result.rb

@@ -0,0 +1,32 @@
+# (c) Copyright IBM Corp. 2025
+
+module Instana
+  module Trace
+    module Samplers
+      class Result
+        EMPTY_HASH = {}.freeze
+        attr_reader :tracestate, :attributes
+
+        def initialize(decision:, tracestate:, attributes: nil)
+          @decision = decision
+          @attributes = attributes.freeze || EMPTY_HASH
+          @tracestate = tracestate
+        end
+
+        # Returns true if this span should be sampled.
+        #
+        # @return FALSE always
+        def sampled?
+          false
+        end
+
+        # Returns true if this span should record events, attributes, status, etc.
+        #
+        # returns TRUE always
+        def recording?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/instana/samplers/samplers.rb

@@ -0,0 +1,76 @@
+# (c) Copyright IBM Corp. 2025
+require 'instana/samplers/result'
+module Instana
+  module Trace
+    # The Samplers module contains the sampling logic for OpenTelemetry. The
+    # reference implementation provides a {TraceIdRatioBased}, {ALWAYS_ON},
+    # {ALWAYS_OFF}, and {ParentBased}.
+    #
+    # Custom samplers can be provided by SDK users. The required interface is:
+    #
+    #   should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:) -> Result
+    #   description -> String
+    #
+    # Where:
+    #
+    # @param [String] trace_id The trace_id of the {Span} to be created.
+    # @param [OpenTelemetry::Context] parent_context The
+    #   {OpenTelemetry::Context} with a parent {Span}. The {Span}'s
+    #   {OpenTelemetry::Trace::SpanContext} may be invalid to indicate a
+    #   root span.
+    # @param [Enumerable<Link>] links A collection of links to be associated
+    #   with the {Span} to be created. Can be nil.
+    # @param [String] name Name of the {Span} to be created.
+    # @param [Symbol] kind The {OpenTelemetry::Trace::SpanKind} of the {Span}
+    #   to be created. Can be nil.
+    # @param [Hash<String, Object>] attributes Attributes to be attached
+    #   to the {Span} to be created. Can be nil.
+    # @return [Result] The sampling result.
+    module Samplers
+      # Returns a {Result} with {Decision::RECORD_AND_SAMPLE}.
+      ALWAYS_ON = false
+      # # Returns a {Result} with {Decision::DROP}.
+      ALWAYS_OFF = true
+
+      # Returns a new sampler. It delegates to samplers according to the following rules:
+      #
+      # | Parent | parent.remote? | parent.trace_flags.sampled? | Invoke sampler |
+      # |--|--|--|--|
+      # | absent | n/a | n/a | root |
+      # | present | true | true | remote_parent_sampled |
+      # | present | true | false | remote_parent_not_sampled |
+      # | present | false | true | local_parent_sampled |
+      # | present | false | false | local_parent_not_sampled |
+      #
+      # @param [Sampler] root The sampler to which the sampling
+      #   decision is delegated for spans with no parent (root spans).
+      # @param [optional Sampler] remote_parent_sampled The sampler to which the sampling
+      #   decision is delegated for remote parent sampled spans. Defaults to ALWAYS_ON.
+      # @param [optional Sampler] remote_parent_not_sampled The sampler to which the sampling
+      #   decision is delegated for remote parent not sampled spans. Defaults to ALWAYS_OFF.
+      # @param [optional Sampler] local_parent_sampled The sampler to which the sampling
+      #   decision is delegated for local parent sampled spans. Defaults to ALWAYS_ON.
+      # @param [optional Sampler] local_parent_not_sampled The sampler to which the sampling
+      #   decision is delegated for local parent not sampld spans. Defaults to ALWAYS_OFF.
+      def self.parent_based(_)
+        self
+      end
+
+      # Returns a new sampler. The ratio describes the proportion of the trace ID
+      # space that is sampled.
+      #
+      # @param [Numeric] ratio The desired sampling ratio.
+      #   Must be within [0.0, 1.0].
+      # @raise [ArgumentError] if ratio is out of range
+      def self.trace_id_ratio_based(_)
+        self
+      end
+
+      def self.should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:) # rubocop:disable Metrics/ParameterLists, Lint/UnusedMethodArgument:
+        parent_span_context = OpenTelemetry::Trace.current_span(parent_context).context
+        tracestate = parent_span_context&.tracestate
+        Result.new(decision: :__record_only__, tracestate: tracestate)
+      end
+    end
+  end
+end

data/lib/instana/serverless.rb

@@ -42,8 +42,10 @@ module Instana
       else
         tags[:lambda] = tags[:lambda].merge(event_tags)
       end
-
-      @tracer.start_or_continue_trace(:'aws.lambda.entry', tags, span_context, &block)
+      Trace.with_span(OpenTelemetry::Trace.non_recording_span(::Instana::SpanContext.new(trace_id: span_context[:trace_id], span_id: span_context[:span_id],
+                                                                                         level: span_context[:level]))) do
+        @tracer.in_span(:'aws.lambda.entry', attributes: tags, &block)
+      end
     ensure
       begin
         @agent.send_bundle

data/lib/instana/setup.rb

@@ -11,8 +11,8 @@ require 'instana/instrumented_logger'
 require "instana/base"
 require "instana/config"
 require "instana/secrets"
-require "instana/tracer"
-require "instana/tracing/processor"
+require "instana/trace/tracer"
+require "instana/trace/processor"
 
 require 'instana/serverless'
 
@@ -39,13 +39,13 @@ require 'instana/backend/host_agent_reporting_observer'
 require 'instana/backend/host_agent'
 require 'instana/backend/serverless_agent'
 require 'instana/backend/agent'
+require 'instana/trace'
+require 'instana/trace/tracer_provider'
+require 'instana/span_filtering'
 
 ::Instana.setup
 ::Instana.agent.setup
 
-# Require supported OpenTracing interfaces
-require "opentracing"
-
 # The Instana agent is now setup.  The only remaining
 # task for a complete boot is to call
 # `Instana.agent.start` in the thread of your choice.

data/lib/instana/span_filtering/condition.rb

@@ -0,0 +1,134 @@
+# (c) Copyright IBM Corp. 2025
+
+module Instana
+  module SpanFiltering
+    # Represents a condition for filtering spans
+    #
+    # A condition consists of:
+    # - key: The attribute to match against (category, kind, type, or span attribute)
+    # - values: List of values to match against (OR logic between values)
+    # - match_type: String matching strategy (strict, startswith, endswith, contains)
+    class Condition
+      attr_reader :key, :values, :match_type
+
+      def initialize(key, values, match_type = 'strict')
+        @key = key
+        @values = Array(values)
+        @match_type = match_type
+      end
+
+      # Check if a span matches this condition
+      # @param span [Hash] The span to check
+      # @return [Boolean] True if the span matches any of the values
+      def matches?(span)
+        attribute_value = extract_attribute(span, @key)
+        return false if attribute_value.nil?
+
+        @values.any? { |value| matches_value?(attribute_value, value) }
+      end
+
+      private
+
+      # Extract an attribute from a span
+      # @param span [Hash] The span to extract from
+      # @param key [String] The key to extract
+      # @return [Object, nil] The attribute value or nil if not found
+      def extract_attribute(span, key)
+        case key
+        when 'category'
+          # Map to appropriate span attribute for category
+          determine_category(span)
+        when 'kind'
+          # Map to appropriate span attribute for kind
+          span[:k] || span['k']
+        when 'type'
+          # Map to appropriate span attribute for type
+          span[:n] || span['n']
+        else
+          # Handle nested attributes with dot notation
+          extract_nested_attribute(span[:data] || span['data'], key)
+        end
+      end
+
+      # Determine the category of a span based on its properties
+      # @param span [Hash] The span to categorize
+      # @return [String, nil] The category or nil if not determinable
+      def determine_category(span)
+        data = span[:data] || span['data']
+        return nil unless data
+
+        if data[:http] || data['http']
+          'protocols'
+        elsif data[:redis] || data[:mysql] || data[:pg] || data[:db]
+          'databases'
+        elsif data[:sqs] || data[:sns] || data[:mq]
+          'messaging'
+        elsif (span[:n] || span['n'])&.start_with?('log.')
+          'logging'
+        end
+      end
+
+      # Extract a nested attribute using dot notation
+      # @param data [Hash] The data hash to extract from
+      # @param key [String] The key in dot notation
+      # @return [Object, nil] The attribute value or nil if not found
+      def extract_nested_attribute(data, key)
+        return nil unless data
+
+        parts = key.split('.')
+        current = data
+
+        parts.each do |part|
+          # Try symbol key first, then string key
+          if current.key?(part.to_sym)
+            current = current[part.to_sym]
+          elsif current.key?(part)
+            current = current[part]
+          else
+            return nil # Key not found
+          end
+
+          # Only return nil if the value is actually nil, not for false values
+        end
+
+        current
+      end
+
+      # Check if an attribute value matches a condition value
+      # @param attribute_value [Object] The attribute value
+      # @param condition_value [String] The condition value
+      # @return [Boolean] True if the attribute value matches the condition value
+      def matches_value?(attribute_value, condition_value)
+        # Handle wildcard
+        return true if condition_value == '*'
+
+        # Direct comparison first - this should handle boolean values correctly
+        return true if attribute_value == condition_value
+
+        # For strict matching with type conversion
+        if @match_type == 'strict'
+          # Convert to strings and compare
+          attribute_str = attribute_value.to_s
+          condition_str = condition_value.to_s
+          return attribute_str == condition_str
+        end
+
+        # For other match types, convert both to strings
+        attribute_str = attribute_value.to_s
+        condition_str = condition_value.to_s
+
+        case @match_type
+        when 'startswith'
+          attribute_str.start_with?(condition_str)
+        when 'endswith'
+          attribute_str.end_with?(condition_str)
+        when 'contains'
+          attribute_str.include?(condition_str)
+        else
+          # Default to strict matching
+          attribute_str == condition_str
+        end
+      end
+    end
+  end
+end

data/lib/instana/span_filtering/configuration.rb

@@ -0,0 +1,262 @@
+# (c) Copyright IBM Corp. 2025
+
+require 'yaml'
+
+module Instana
+  module SpanFiltering
+    # Configuration class for span filtering
+    #
+    # This class handles loading and managing span filtering rules from various sources:
+    # - YAML configuration file (via INSTANA_CONFIG_PATH)
+    # - Environment variables
+    # - Agent discovery response
+    # It supports both include and exclude rules with various matching strategies
+    class Configuration
+      attr_reader :include_rules, :exclude_rules, :deactivated
+
+      TRACING_CONFIG_WARNING = 'Please use "tracing" instead of "com.instana.tracing" for local configuration file.'.freeze
+
+      def initialize
+        @include_rules = []
+        @exclude_rules = []
+        @deactivated = false
+        load_configuration
+      end
+
+      # Load configuration from all available sources
+      def load_configuration
+        load_from_yaml
+        load_from_env_vars unless rules_loaded?
+        load_from_agent unless rules_loaded?
+      end
+
+      private
+
+      # Load configuration from agent discovery response
+      def load_from_agent
+        # Try to get discovery value immediately first
+        discovery = ::Instana.agent&.delegate&.send(:discovery_value)
+        if discovery && discovery.is_a?(Hash) && !discovery.empty?
+          process_discovery_config(discovery)
+          return
+        end
+
+        # If not available, set up a timer task to periodically check for discovery
+        setup_discovery_timer
+      rescue => e
+        Instana.logger.warn("Failed to load span filtering configuration from agent: #{e.message}")
+      end
+
+      # Set up a timer task to periodically check for discovery
+      def setup_discovery_timer
+        # Don't create a timer task if we're in a test environment
+        return if ENV.key?('INSTANA_TEST')
+
+        # Create a timer task that checks for discovery every second
+        @discovery_timer = Concurrent::TimerTask.new(execution_interval: 1) do
+          check_discovery
+        end
+
+        # Start the timer task
+        @discovery_timer.execute
+      end
+
+      # Check if discovery is available and process it
+      def check_discovery
+        discovery = ::Instana.agent&.delegate.send(:discovery_value)
+        if discovery && discovery.is_a?(Hash) && !discovery.empty?
+          process_discovery_config(discovery)
+
+          # Shutdown the timer task after successful processing
+          @discovery_timer.shutdown if @discovery_timer
+
+          return true
+        end
+
+        false
+      rescue => e
+        Instana.logger.warn("Error checking discovery in timer task: #{e.message}")
+        false
+      end
+
+      # Process the discovery configuration
+      def process_discovery_config(discovery)
+        # Check if tracing configuration exists in the discovery response
+        tracing_config = discovery['tracing']
+        return unless tracing_config
+
+        # Process filter configuration
+        if tracing_config['filter']
+          filter_config = tracing_config['filter']
+          @deactivated = filter_config['deactivate'] == true
+
+          # Process include rules
+          process_rules(filter_config['include'], true) if filter_config['include']
+
+          # Process exclude rules
+          process_rules(filter_config['exclude'], false) if filter_config['exclude']
+        end
+
+        # Process disable configuration
+        if tracing_config['disable']
+          process_disable_config(tracing_config['disable'])
+        end
+
+        # Return true to indicate successful processing
+        true
+      rescue => e
+        Instana.logger.warn("Failed to process discovery configuration: #{e.message}")
+        false
+      end
+
+      # Check if the rules are already loaded
+      def rules_loaded?
+        @include_rules.any? || @exclude_rules.any?
+      end
+
+      # Load configuration from YAML file specified by INSTANA_CONFIG_PATH
+      def load_from_yaml
+        config_path = ENV['INSTANA_CONFIG_PATH']
+        return unless config_path && File.exist?(config_path)
+
+        begin
+          yaml_content = YAML.safe_load(File.read(config_path))
+
+          # Support both "tracing" and "com.instana.tracing" as top-level keys
+          tracing_config = yaml_content['tracing'] || yaml_content['com.instana.tracing']
+          ::Instana.logger.warn(TRACING_CONFIG_WARNING) if yaml_content.key?('com.instana.tracing')
+          return unless tracing_config
+
+          # Process filter configuration
+          if tracing_config['filter']
+            filter_config = tracing_config['filter']
+            @deactivated = filter_config['deactivate'] == true
+
+            # Process include rules
+            process_rules(filter_config['include'], true) if filter_config['include']
+
+            # Process exclude rules
+            process_rules(filter_config['exclude'], false) if filter_config['exclude']
+          end
+
+          # Process disable configuration
+          if tracing_config['disable']
+            process_disable_config(tracing_config['disable'])
+          end
+        rescue => e
+          Instana.logger.warn("Failed to load span filtering configuration from YAML: #{e.message}")
+        end
+      end
+
+      # Load configuration from environment variables
+      def load_from_env_vars
+        ENV.each do |key, value|
+          next unless key.start_with?('INSTANA_TRACING_FILTER_')
+
+          parts = key.split('_')
+          next unless parts.size >= 5
+
+          policy = parts[3].downcase
+          next unless ['include', 'exclude'].include?(policy)
+
+          if parts[4] == 'ATTRIBUTES'
+            process_env_attributes(policy, parts[4..].join('_'), value)
+          elsif policy == 'exclude' && parts[4] == 'SUPPRESSION'
+            process_env_suppression(parts[3..].join('_'), value)
+          end
+        end
+
+        return unless !ENV["INSTANA_TRACING_DISABLE"].nil? && !%w[True true 1].include?(ENV["INSTANA_TRACING_DISABLE"])
+
+        process_disable_config(ENV["INSTANA_TRACING_DISABLE"].split(','))
+      end
+
+      # Process rules from YAML configuration
+      def process_rules(rules_config, is_include)
+        rules_config.each do |rule_config|
+          name = rule_config['name']
+          suppression = is_include ? false : (rule_config['suppression'] != false) # Default true for exclude
+
+          conditions = []
+          rule_config['attributes'].each do |attr_config|
+            key = attr_config['key']
+            values = attr_config['values']
+            match_type = attr_config['match_type'] || 'strict'
+
+            conditions << Condition.new(key, values, match_type)
+          end
+
+          rule = FilterRule.new(name, suppression, conditions)
+          is_include ? @include_rules << rule : @exclude_rules << rule
+        end
+      end
+
+      # Process attributes from environment variables
+      def process_env_attributes(policy, name, value)
+        # Parse rules from environment variable format
+        # Format: key;values;match_type|key;values;match_type
+        rules = value.split('|')
+        conditions = []
+
+        rules.each do |rule|
+          parts = rule.split(';')
+          next unless parts.size >= 2
+
+          key = parts[0]
+          values = parts[1].split(',')
+          match_type = parts[2] || 'strict'
+
+          conditions << Condition.new(key, values, match_type)
+        end
+
+        rule_name = "EnvRule_#{name}"
+        suppression = policy == 'exclude' # Default true for exclude
+
+        rule = FilterRule.new(rule_name, suppression, conditions)
+        policy == 'include' ? @include_rules << rule : @exclude_rules << rule
+      end
+
+      # Process suppression setting from environment variables
+      def process_env_suppression(policy_name, value)
+        # Find the corresponding rule and update its suppression value
+        rule_index = policy_name.split('_')[1].to_i
+        return if rule_index >= @exclude_rules.size
+
+        suppression = %w[1 true True].include?(value)
+        @exclude_rules[rule_index].suppression = suppression
+      end
+
+      # Process disable configuration from YAML or agent discovery
+      # @param disable_config [Array] The disable configuration array
+      def process_disable_config(disable_config)
+        return unless disable_config.is_a?(Array)
+
+        disable_config.each do |item|
+          if item.is_a?(Hash)
+            item.each do |key, value|
+              if value == true
+                update_instana_config_for_disabled_technology(key)
+              end
+            end
+          elsif item.is_a?(String)
+            update_instana_config_for_disabled_technology(item)
+          end
+        end
+      end
+
+      # Update Instana::Config for a disabled technology
+      # @param technology [String] The technology to disable
+      def update_instana_config_for_disabled_technology(technology)
+        tech_sym = technology.to_sym
+
+        case tech_sym
+        when :redis
+          ::Instana.config[:redis][:enabled] = false
+        when :databases
+          # If databases category is disabled, also disable redis
+          ::Instana.config[:redis][:enabled] = false
+        end
+      end
+    end
+  end
+end

data/lib/instana/span_filtering/filter_rule.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# (c) Copyright IBM Corp. 2025
+
+module Instana
+  module SpanFiltering
+    # Represents a filtering rule for spans
+    #
+    # A rule consists of:
+    # - name: A human-readable identifier for the rule
+    # - suppression: Whether child spans should be suppressed (only for exclude rules)
+    # - conditions: A list of conditions that must all be satisfied (AND logic)
+    class FilterRule
+      attr_reader :name
+      attr_accessor :suppression, :conditions
+
+      def initialize(name, suppression, conditions)
+        @name = name
+        @suppression = suppression
+        @conditions = conditions
+      end
+
+      # Check if a span matches this rule
+      # @param span [Hash] The span to check
+      # @return [Boolean] True if the span matches all conditions
+      def matches?(span)
+        @conditions.all? { |condition| condition.matches?(span) }
+      end
+    end
+  end
+end