instana 2.3.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16fe1ce82ea4a8d0324dd72d015792e88af0389d8faecc54dfffe587ccb6ec50
-  data.tar.gz: 7a8f22ed404bcede4d89fc8a2e5dc47f15617c3084ee6a4d7242545fca2e2e6f
+  metadata.gz: 465f9dad91e0e60f443e196091b1b725ed012094a5da4f8d0d9a8c525ba4b0de
+  data.tar.gz: e5c17ed36acd2197cbbc6e83a2c44b64562c7bd1785854fc4e2120fb01a99d3f
 SHA512:
-  metadata.gz: e3a2941ff94173b97d8967d74be38f9f2a5776f38e19b6c2eaa4e4a8af827b3f2c126d58620a6843aae8d342229a6e227f9cb88a1508082b51d89fb00150818e
-  data.tar.gz: bd6fedc2ae15e7533d703e09efdc128af3a9d6be5eb780ce83d3f42f4db91304bb40ab08fb962fc07eba05cee6b6dd587c380d49a8014aafc7f3792f157e380c
+  metadata.gz: ef5f5fe6ff3272ac729be2d1b36f9653a06ab8bc8393e15e897712558c0c09258a8730f08e1ef8f8d7503e8e6168c177afc5c98609616ec5ba9bbdf9aa3a42b5
+  data.tar.gz: aba66786130415c9154453bb7daf853ffa976c7b048cdf15985706b778ee92dad8d963ff02040228c79f22c08f67a0ca9099af90439a99217420b99549632040

data/lib/instana/backend/host_agent_activation_observer.rb

@@ -40,6 +40,9 @@ module Instana
           wait_for_backend(discovery['pid'])
           @logger.debug("Agent ready.")
           @discovery.swap { discovery }
+
+          # Read configuration from agent right after discovery
+          ::Instana.config.read_config_from_agent(discovery)
         end
 
         socket.close

data/lib/instana/base.rb

@@ -16,6 +16,15 @@ module Instana
     attr_reader :serverless
     attr_accessor :tracer_provider
 
+    ##
+    # span_filtering_config
+    #
+    # Returns the span filtering configuration instance
+    #
+    def span_filtering_config
+      ::Instana::SpanFiltering.configuration
+    end
+
     ##
     # setup
     #

data/lib/instana/config.rb

@@ -1,6 +1,8 @@
 # (c) Copyright IBM Corp. 2021
 # (c) Copyright Instana Inc. 2016
 
+require 'yaml'
+
 module Instana
   class Config
     def initialize(logger: ::Instana.logger, agent_host: ENV['INSTANA_AGENT_HOST'], agent_port: ENV['INSTANA_AGENT_PORT'])
@@ -43,8 +45,9 @@ module Instana
       # In Ruby, backtrace collection is very expensive so it's
       # (unfortunately) disabled by default.  If you still want
       # backtraces, it can be enabled with this config option.
-      # ::Instana.config[:collect_backtraces] = true
-      @config[:collect_backtraces] = false
+      # @config[:back_trace][:stack_trace_level] = all
+      # @config[:back_trace] = { stack_trace_level: nil }
+      read_span_stack_config
 
       # By default, collected SQL will be sanitized to remove potentially sensitive bind params such as:
       #   > SELECT  "blocks".* FROM "blocks"  WHERE "blocks"."name" = "Mr. Smith"
@@ -86,6 +89,177 @@ module Instana
     def []=(key, value)
       @config[key.to_sym] = value
     end
+
+    # Read stack trace configuration from environment variables, YAML file, or use defaults
+    # Priority: Environment variables > YAML file > Agent discovery > Defaults
+    def read_span_stack_config
+      # Try environment variables first
+      if ENV['INSTANA_STACK_TRACE'] || ENV['INSTANA_STACK_TRACE_LENGTH']
+        read_span_stack_config_from_env
+        @config[:back_trace_technologies] = {}
+        return
+      end
+
+      # Try YAML file
+      yaml_config = read_span_stack_config_from_yaml
+      if yaml_config
+        @config[:back_trace] = yaml_config[:global]
+        @config[:back_trace_technologies] = yaml_config[:technologies] || {}
+        return
+      end
+
+      # Use defaults
+      apply_default_stack_trace_config
+    end
+
+    # Read configuration from agent discovery response
+    # This is called after agent discovery is complete
+    # @param discovery [Hash] The discovery response from the agent
+    def read_config_from_agent(discovery)
+      return unless discovery.is_a?(Hash) && discovery['tracing']
+
+      tracing_config = discovery['tracing']
+
+      # Read stack trace configuration from agent if not already set from YAML or env
+      read_span_stack_config_from_agent(tracing_config) if should_read_from_agent?(:back_trace)
+      # Read span filtering configuration from agent
+      ::Instana.span_filtering_config&.read_config_from_agent(discovery)
+    rescue => e
+      ::Instana.logger.warn("Failed to read configuration from agent: #{e.message}")
+    end
+
+    # Read stack trace configuration from agent discovery
+    # @param tracing_config [Hash] The tracing configuration from discovery
+    def read_span_stack_config_from_agent(tracing_config)
+      return unless tracing_config['global']
+
+      global_config = parse_global_stack_trace_config(tracing_config['global'], 'agent')
+      @config[:back_trace] = global_config if global_config
+
+      # Read technology-specific configurations
+      @config[:back_trace_technologies] = parse_technology_configs(tracing_config)
+    end
+
+    # Read stack trace configuration from YAML file
+    # Returns hash with :global and :technologies keys or nil if not found
+    def read_span_stack_config_from_yaml
+      config_path = ENV['INSTANA_CONFIG_PATH']
+      return nil 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
+        if yaml_content['com.instana.tracing']
+          ::Instana.logger.warn('Please use "tracing" instead of "com.instana.tracing"')
+        end
+        tracing_config = yaml_content['tracing'] || yaml_content['com.instana.tracing']
+        return nil unless tracing_config
+
+        result = {}
+
+        # Look for global stack trace configuration
+        if tracing_config['global']
+          global_config = parse_global_stack_trace_config(tracing_config['global'], 'yaml')
+          result[:global] = global_config if global_config
+        end
+
+        # Look for technology-specific configurations
+        technologies = parse_technology_configs(tracing_config)
+        result[:technologies] = technologies unless technologies.empty?
+
+        result.empty? ? nil : result
+      rescue => e
+        ::Instana.logger.warn("Failed to load stack trace configuration from YAML: #{e.message}")
+        nil
+      end
+    end
+
+    # Read stack trace configuration from environment variables
+    def read_span_stack_config_from_env
+      @config[:back_trace] = {
+        stack_trace_level: ENV['INSTANA_STACK_TRACE'] || 'error',
+        stack_trace_length: ENV['INSTANA_STACK_TRACE_LENGTH']&.to_i || 30,
+        config_source: 'env'
+      }
+    end
+
+    # Apply default stack trace configuration
+    def apply_default_stack_trace_config
+      @config[:back_trace] = {
+        stack_trace_level: 'error',
+        stack_trace_length: 30,
+        config_source: 'default'
+      }
+      @config[:back_trace_technologies] = {}
+    end
+
+    # Check if we should read configuration from agent
+    # Returns true if config was not set from YAML or environment variables
+    def should_read_from_agent?(config_key)
+      return true unless @config[config_key]
+
+      source = @config[config_key][:config_source]
+      source.nil? || source == 'default'
+    end
+
+    # Get stack trace configuration for a specific technology
+    # Falls back to global configuration if technology-specific config is not found
+    # @param technology [Symbol] The technology name (e.g., :excon, :kafka, :activerecord)
+    # @return [Hash] Configuration hash with :stack_trace_level and :stack_trace_length
+    def get_stack_trace_config(technology)
+      tech_config = @config[:back_trace_technologies]&.[](technology)
+      global_config = @config[:back_trace] || {}
+
+      {
+        stack_trace_level: tech_config&.[](:stack_trace_level) || global_config[:stack_trace_level] || 'error',
+        stack_trace_length: tech_config&.[](:stack_trace_length) || global_config[:stack_trace_length] || 30
+      }
+    end
+
+    private
+
+    # Parse global stack trace configuration from a config hash
+    # @param global_config [Hash] The global configuration hash
+    # @param config_source [String] The source of the configuration ('yaml', 'agent', etc.)
+    # @return [Hash, nil] Parsed configuration or nil if no valid config found
+    def parse_global_stack_trace_config(global_config, config_source)
+      return nil unless global_config.is_a?(Hash)
+
+      stack_trace_level = global_config['stack-trace']
+      stack_trace_length = global_config['stack-trace-length']
+
+      # Only return config if at least one value is present
+      return nil unless stack_trace_level || stack_trace_length
+
+      {
+        stack_trace_level: stack_trace_level || 'error',
+        stack_trace_length: stack_trace_length ? stack_trace_length.to_i : 30,
+        config_source: config_source
+      }
+    end
+
+    # Parse technology-specific stack trace configurations from tracing config
+    # @param tracing_config [Hash] The tracing configuration hash
+    # @return [Hash] Technology-specific configurations
+    def parse_technology_configs(tracing_config)
+      technologies = {}
+      tracing_config.each do |key, value|
+        next if key == 'global' || !value.is_a?(Hash)
+
+        tech_stack_trace = value['stack-trace']
+        tech_stack_trace_length = value['stack-trace-length']
+
+        next unless tech_stack_trace || tech_stack_trace_length
+
+        technologies[key.to_sym] = {
+          stack_trace_level: tech_stack_trace,
+          stack_trace_length: tech_stack_trace_length ? tech_stack_trace_length.to_i : nil
+        }.compact
+      end
+      technologies
+    end
+
   end
 end
 

data/lib/instana/span_filtering/configuration.rb

@@ -27,57 +27,21 @@ module Instana
       def load_configuration
         load_from_yaml
         load_from_env_vars unless rules_loaded?
-        load_from_agent unless rules_loaded?
+        # Agent configuration will be loaded after discovery via read_config_from_agent
       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
+      # Read configuration from agent discovery response
+      # This is called from Config#read_config_from_agent after discovery is complete
+      # @param discovery [Hash] The discovery response from the agent
+      def read_config_from_agent(discovery)
+        return if rules_loaded? # Don't override if already loaded from YAML or env
 
-        # If not available, set up a timer task to periodically check for discovery
-        setup_discovery_timer
+        process_discovery_config(discovery)
       rescue => e
-        Instana.logger.warn("Failed to load span filtering configuration from agent: #{e.message}")
+        Instana.logger.warn("Failed to read 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
+      private
 
       # Process the discovery configuration
       def process_discovery_config(discovery)

data/lib/instana/trace/span.rb

@@ -70,27 +70,31 @@ module Instana
       set_tags(attributes)
       ::Instana.processor.on_start(self)
       # Attach a backtrace to all exit spans
-      add_stack if ::Instana.config[:collect_backtraces] && exit_span?
+      add_stack if should_collect_stack_trace?
     end
 
     # Adds a backtrace to this span
     #
     # @param limit [Integer] Limit the backtrace to the top <limit> frames
     #
-    def add_stack(limit: 30, stack: Kernel.caller)
+    def add_stack(span_stack_config: nil, stack: Kernel.caller)
+      # Get technology-specific config if not provided
+      span_stack_config ||= current_span_stack_config
+
+      limit = span_stack_config[:stack_trace_length]
       cleaner = ::Instana.config[:backtrace_cleaner]
       stack = cleaner.call(stack) if cleaner
 
       @attributes[:stack] = stack
                             .map do |call|
-        file, line, *method = call.split(':')
+                              file, line, *method = call.split(':')
 
-        {
-          c: file,
-          n: line,
-          m: method.join(' ')
-        }
-      end.take(limit > 40 ? 40 : limit)
+                              {
+                                c: file,
+                                n: line,
+                                m: method.join(' ')
+                              }
+      end.take([limit, 40].min)
     end
 
     # Log an error into the span
@@ -530,5 +534,20 @@ module Instana
     #
     # @return [void]
     def status=(status); end
+
+    def should_collect_stack_trace?
+      return false unless exit_span?
+
+      config = current_span_stack_config
+      config[:stack_trace_level] == "all"
+    end
+
+    # Get the stack trace configuration for this span's technology
+    # Falls back to global configuration if technology-specific config is not found
+    # @return [Hash] Configuration hash with :stack_trace_level and :stack_trace_length
+    def current_span_stack_config
+      technology = @attributes[:n]
+      ::Instana.config.get_stack_trace_config(technology)
+    end
   end
 end

data/lib/instana/version.rb

@@ -2,6 +2,6 @@
 # (c) Copyright Instana Inc. 2016
 
 module Instana
-  VERSION = "2.3.0"
+  VERSION = "2.5.0"
   VERSION_FULL = "instana-#{VERSION}"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: instana
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Peter Giacomo Lombardo
@@ -191,6 +191,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: cgi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
@@ -348,7 +362,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.2
+rubygems_version: 4.0.7
 specification_version: 4
 summary: Ruby Distributed Tracing & Metrics Sensor for Instana
 test_files: []