hyperprobe-agent 1.2.27.pre.1

data/lib/hyperprobe/core/serializer.rb

@@ -0,0 +1,425 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+require 'set'
+
+module HyperProbe
+  module Core
+    class Serializer
+      DEFAULT_MAX_DEPTH = 3
+      DEFAULT_MAX_ARRAY_LENGTH = 3
+      DEFAULT_MAX_OBJECT_PROPERTIES = 50
+      DEFAULT_MAX_STRING_LENGTH = 1024
+
+      def initialize(
+        max_depth: DEFAULT_MAX_DEPTH,
+        max_array_length: DEFAULT_MAX_ARRAY_LENGTH,
+        max_object_properties: DEFAULT_MAX_OBJECT_PROPERTIES,
+        max_string_length: DEFAULT_MAX_STRING_LENGTH,
+        redact_keys: nil,
+        redact_values: nil
+      )
+        @max_depth = max_depth || DEFAULT_MAX_DEPTH
+        @max_array_length = max_array_length || DEFAULT_MAX_ARRAY_LENGTH
+        @max_object_properties = max_object_properties || DEFAULT_MAX_OBJECT_PROPERTIES
+        @max_string_length = max_string_length || DEFAULT_MAX_STRING_LENGTH
+        @redact_keys_re = compile_regex(redact_keys)
+        @redact_values_re = compile_regex(redact_values)
+      end
+
+      def serialize(obj, path = '$', depth = 0, visited = {})
+        return nil if obj.nil?
+        return obj if obj == true || obj == false
+        return serialize_number(obj) if obj.is_a?(Numeric)
+        return serialize_string(obj) if obj.is_a?(String)
+        return obj.to_s if obj.is_a?(Symbol)
+        return serialize_callable(obj) if callable?(obj)
+        return serialize_time(obj) if time_object?(obj)
+        return serialize_exception(obj) if obj.is_a?(Exception)
+        return serialize_java_throwable(obj) if java_throwable?(obj)
+        return obj.inspect if obj.is_a?(Regexp) || obj.is_a?(Range)
+
+        # Reference / Cycle check (immediate primitives like symbols/integers/floats/true/false are handled above)
+        obj_id = obj.object_id
+        if visited.key?(obj_id)
+          return "[REF - #{visited[obj_id]}]"
+        end
+
+        # Depth check
+        if depth > @max_depth
+          return summary_of(obj)
+        end
+
+        # Track visited for complex objects
+        visited[obj_id] = path
+
+        if obj.is_a?(Array)
+          serialize_array(obj, path, depth, visited)
+        elsif obj.is_a?(Set)
+          serialize_array(obj.to_a, path, depth, visited)
+        elsif obj.is_a?(Hash)
+          serialize_hash(obj, path, depth, visited)
+        elsif java_map?(obj)
+          serialize_java_map(obj, path, depth, visited)
+        elsif java_list?(obj)
+          serialize_java_list(obj, path, depth, visited)
+        elsif java_set?(obj)
+          serialize_java_set(obj, path, depth, visited)
+        elsif obj.is_a?(Struct) || (defined?(OpenStruct) && obj.is_a?(OpenStruct))
+          serialize_struct(obj, path, depth, visited)
+        elsif java_object?(obj)
+          serialize_java_pojo(obj, path, depth, visited)
+        else
+          serialize_object(obj, path, depth, visited)
+        end
+      end
+
+      def self.safe_dump_json(data)
+        JSON.generate(data)
+      rescue StandardError => e
+        JSON.generate({ 'error' => "JSON serialization failed: #{e.message}" })
+      end
+
+      private
+
+      def compile_regex(patterns)
+        return nil if patterns.nil? || patterns.empty?
+
+        valid = Array(patterns).map(&:to_s).map(&:strip).reject(&:empty?)
+        return nil if valid.empty?
+
+        Regexp.union(valid.map { |p| Regexp.new(p, Regexp::IGNORECASE) })
+      rescue StandardError
+        nil
+      end
+
+      def serialize_number(num)
+        if num.is_a?(Float)
+          return 'NaN' if num.nan?
+          return 'Infinity' if num.infinite? && num.positive?
+          return '-Infinity' if num.infinite? && num.negative?
+        end
+        num
+      end
+
+      def serialize_string(str)
+        val = str.dup
+        if @redact_values_re && @redact_values_re.match?(val)
+          val = val.gsub(@redact_values_re, '[REDACTED Value]')
+        end
+
+        if val.length > @max_string_length
+          head = val[0...@max_string_length]
+          # Match Node.js truncated head word boundary trimming
+          truncated_head = head.sub(/\b\w*$/, '').rstrip
+          truncated_head = head if truncated_head.empty?
+          val = "#{truncated_head}... [Truncated: +#{val.length - @max_string_length} more chars]"
+        end
+        val
+      end
+
+      def callable?(obj)
+        obj.is_a?(Proc) || obj.is_a?(Method) || obj.is_a?(UnboundMethod)
+      end
+
+      def serialize_callable(obj)
+        name = if obj.respond_to?(:name) && obj.name
+                 ": #{obj.name}"
+               elsif obj.lambda?
+                 ': (lambda)'
+               else
+                 ''
+               end
+        "[Function#{name}]"
+      end
+
+      def time_object?(obj)
+        obj.is_a?(Time) || obj.is_a?(Date) || (defined?(DateTime) && obj.is_a?(DateTime))
+      end
+
+      def serialize_time(obj)
+        obj.respond_to?(:iso8601) ? obj.iso8601 : obj.to_s
+      end
+
+      def serialize_exception(obj)
+        stack = if obj.backtrace
+                  obj.backtrace.first(3).join("\n") + '...'
+                end
+        {
+          'name' => obj.class.name,
+          'message' => obj.message,
+          'stack' => stack
+        }
+      end
+
+      def serialize_array(arr, path, depth, visited)
+        result = []
+        len = [arr.length, @max_array_length].min
+
+        (0...len).each do |i|
+          elem = arr[i]
+          elem_path = "#{path}[#{i}]"
+          result << serialize(elem, elem_path, depth + 1, visited)
+        rescue StandardError => e
+          result << "[Error: #{e.message}]"
+        end
+
+        if arr.length > @max_array_length
+          result << "[+ #{arr.length - @max_array_length} more items truncated]"
+        end
+
+        result
+      end
+
+      def serialize_hash(hash, path, depth, visited)
+        result = {}
+        keys = hash.keys
+        limit = @max_object_properties
+        num_to_process = [keys.length, limit].min
+
+        (0...num_to_process).each do |i|
+          key = keys[i]
+          key_str = key.to_s
+
+          if @redact_keys_re && @redact_keys_re.match?(key_str)
+            result[key_str] = '[REDACTED Key]'
+            next
+          end
+
+          child_path = path == '$' ? key_str : "#{path}.#{key_str}"
+          val = hash[key]
+          result[key_str] = serialize(val, child_path, depth + 1, visited)
+        rescue StandardError => e
+          result[key_str] = "[Error accessing property: #{e.message}]"
+        end
+
+        if keys.length > limit
+          result['__probe_meta'] = "+ #{keys.length - limit} more properties truncated"
+        end
+
+        result
+      end
+
+      def serialize_struct(struct_obj, path, depth, visited)
+        hash = struct_obj.to_h
+        serialize_hash(hash, path, depth, visited)
+      rescue StandardError
+        serialize_object(struct_obj, path, depth, visited)
+      end
+
+      # Java Collection & POJO Serialization for JRuby
+      def serialize_java_map(map, path, depth, visited)
+        result = {}
+        keys = (map.respond_to?(:keySet) ? map.keySet.to_a : map.keys) rescue []
+        limit = @max_object_properties
+        num_to_process = [keys.length, limit].min
+
+        (0...num_to_process).each do |i|
+          key = keys[i]
+          key_str = key.to_s
+
+          if @redact_keys_re && @redact_keys_re.match?(key_str)
+            result[key_str] = '[REDACTED Key]'
+            next
+          end
+
+          child_path = path == '$' ? key_str : "#{path}.#{key_str}"
+          val = map.respond_to?(:get) ? map.get(key) : map[key] rescue map[key]
+          result[key_str] = serialize(val, child_path, depth + 1, visited)
+        rescue StandardError => e
+          result[key_str] = "[Error accessing property: #{e.message}]"
+        end
+
+        if keys.length > limit
+          result['__probe_meta'] = "+ #{keys.length - limit} more properties truncated"
+        end
+
+        result
+      end
+
+      def serialize_java_list(list, path, depth, visited)
+        result = []
+        size = (list.respond_to?(:size) ? list.size : list.length) rescue 0
+        len = [size, @max_array_length].min
+
+        (0...len).each do |i|
+          elem = list.respond_to?(:get) ? list.get(i) : list[i] rescue list[i]
+          elem_path = "#{path}[#{i}]"
+          result << serialize(elem, elem_path, depth + 1, visited)
+        rescue StandardError => e
+          result << "[Error: #{e.message}]"
+        end
+
+        if size > @max_array_length
+          result << "[+ #{size - @max_array_length} more items truncated]"
+        end
+
+        result
+      end
+
+      def serialize_java_set(set, path, depth, visited)
+        arr = (set.respond_to?(:toArray) ? set.toArray.to_a : set.to_a) rescue []
+        serialize_array(arr, path, depth, visited)
+      end
+
+      def serialize_java_throwable(throwable)
+        stack_elements = nil
+        if throwable.respond_to?(:getStackTrace)
+          stack_elements = (throwable.getStackTrace.to_a.first(3).map(&:toString).join("\n") + '...') rescue nil
+        end
+        class_name = throwable.respond_to?(:getClass) ? throwable.getClass.getName : throwable.class.name
+        message = throwable.respond_to?(:getMessage) ? throwable.getMessage : throwable.to_s
+        {
+          'name' => class_name,
+          'message' => message || '',
+          'stack' => stack_elements
+        }
+      end
+
+      def serialize_java_pojo(obj, path, depth, visited)
+        ivars = obj.instance_variables rescue []
+        if ivars && !ivars.empty?
+          return serialize_object(obj, path, depth, visited)
+        end
+
+        result = {}
+        ignored_methods = %w[getClass getDeclaringClass hashCode toString equals wait notify notifyAll]
+        getters = []
+        begin
+          getters = obj.class.instance_methods(false).select do |m|
+            name = m.to_s
+            (name.start_with?('get') && name.length > 3 || name.start_with?('is') && name.length > 2) && !ignored_methods.include?(name)
+          end
+        rescue StandardError
+          getters = []
+        end
+
+        limit = @max_object_properties
+        num_to_process = [getters.length, limit].min
+
+        (0...num_to_process).each do |i|
+          getter_sym = getters[i]
+          raw_name = getter_sym.to_s
+          prop_name = if raw_name.start_with?('get')
+                        raw_name[3..].sub(/^[A-Z]/, &:downcase)
+                      elsif raw_name.start_with?('is')
+                        raw_name[2..].sub(/^[A-Z]/, &:downcase)
+                      else
+                        raw_name
+                      end
+
+          if @redact_keys_re && @redact_keys_re.match?(prop_name)
+            result[prop_name] = '[REDACTED Key]'
+            next
+          end
+
+          child_path = path == '$' ? prop_name : "#{path}.#{prop_name}"
+          val = obj.public_send(getter_sym)
+          result[prop_name] = serialize(val, child_path, depth + 1, visited)
+        rescue StandardError => e
+          result[prop_name] = "[Error accessing property: #{e.message}]"
+        end
+
+        if getters.length > limit
+          result['__probe_meta'] = "+ #{getters.length - limit} more properties truncated"
+        end
+
+        result.empty? ? summary_of(obj) : result
+      end
+
+      def java_object?(obj)
+        return false unless defined?(JRUBY_VERSION) || defined?(Java)
+        return true if defined?(java.lang.Object) && obj.is_a?(java.lang.Object)
+        return true if obj.respond_to?(:java_class)
+        false
+      rescue StandardError
+        false
+      end
+
+      def java_map?(obj)
+        return false unless defined?(JRUBY_VERSION) || defined?(Java)
+        return true if defined?(java.util.Map) && obj.is_a?(java.util.Map)
+        return true if defined?(Java::JavaUtil::Map) && obj.is_a?(Java::JavaUtil::Map)
+        false
+      rescue StandardError
+        false
+      end
+
+      def java_list?(obj)
+        return false unless defined?(JRUBY_VERSION) || defined?(Java)
+        return true if defined?(java.util.List) && obj.is_a?(java.util.List)
+        return true if defined?(Java::JavaUtil::List) && obj.is_a?(Java::JavaUtil::List)
+        false
+      rescue StandardError
+        false
+      end
+
+      def java_set?(obj)
+        return false unless defined?(JRUBY_VERSION) || defined?(Java)
+        return true if defined?(java.util.Set) && obj.is_a?(java.util.Set)
+        return true if defined?(Java::JavaUtil::Set) && obj.is_a?(Java::JavaUtil::Set)
+        false
+      rescue StandardError
+        false
+      end
+
+      def java_throwable?(obj)
+        return false unless defined?(JRUBY_VERSION) || defined?(Java)
+        return true if defined?(java.lang.Throwable) && obj.is_a?(java.lang.Throwable)
+        return true if defined?(Java::JavaLang::Throwable) && obj.is_a?(Java::JavaLang::Throwable)
+        false
+      rescue StandardError
+        false
+      end
+
+      def serialize_object(obj, path, depth, visited)
+        result = {}
+        ivars = obj.instance_variables
+        limit = @max_object_properties
+        num_to_process = [ivars.length, limit].min
+
+        (0...num_to_process).each do |i|
+          ivar_sym = ivars[i]
+          key_str = ivar_sym.to_s.sub(/^@/, '')
+
+          if @redact_keys_re && @redact_keys_re.match?(key_str)
+            result[key_str] = '[REDACTED Key]'
+            next
+          end
+
+          child_path = path == '$' ? key_str : "#{path}.#{key_str}"
+          val = obj.instance_variable_get(ivar_sym)
+          result[key_str] = serialize(val, child_path, depth + 1, visited)
+        rescue StandardError => e
+          result[key_str] = "[Error accessing property: #{e.message}]"
+        end
+
+        if ivars.length > limit
+          result['__probe_meta'] = "+ #{ivars.length - limit} more properties truncated"
+        end
+
+        # If an object has no instance variables, check if it responds to meaningful getters or to_s
+        if ivars.empty?
+          return summary_of(obj)
+        end
+
+        result
+      end
+
+      def summary_of(obj)
+        return 'null' if obj.nil?
+
+        case obj
+        when String then "[Str: #{obj.length}]"
+        when Array then "[Arr: #{obj.length}]"
+        when Set then "[Set: #{obj.length}]"
+        when Hash then "[Obj: #{obj.length} keys]"
+        when Proc, Method then '[Function]'
+        else
+          "[Obj: #{obj.class.name}]"
+        end
+      end
+    end
+  end
+end

data/lib/hyperprobe/core/trace_extractor.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module HyperProbe
+  module Core
+    class TraceExtractor
+      class << self
+        def extract_trace_context(custom_get_trace_id = nil)
+          # 1. Custom User Hook (Passed via options[:set_trace_id])
+          if custom_get_trace_id.respond_to?(:call)
+            begin
+              trace_id = custom_get_trace_id.call
+              return trace_id.to_s if trace_id && !trace_id.to_s.empty?
+            rescue StandardError
+              # Never fail on user hook error
+            end
+          end
+
+          # 2. OpenTelemetry
+          if defined?(::OpenTelemetry::Trace)
+            begin
+              span = ::OpenTelemetry::Trace.current_span
+              if span && span.respond_to?(:context)
+                ctx = span.context
+                if ctx
+                  if ctx.respond_to?(:hex_trace_id)
+                    trace_id = ctx.hex_trace_id
+                    return trace_id if trace_id && trace_id != '00000000000000000000000000000000'
+                  elsif ctx.respond_to?(:trace_id) && ctx.trace_id
+                    raw_id = ctx.trace_id
+                    hex_id = raw_id.is_a?(String) ? raw_id.unpack1('H*') : raw_id.to_s(16)
+                    return hex_id if hex_id && hex_id != '00000000000000000000000000000000'
+                  end
+                end
+              end
+            rescue StandardError
+              # Silently ignore OTel errors
+            end
+          end
+
+          # 3. Datadog
+          if defined?(::Datadog::Tracing)
+            begin
+              if ::Datadog::Tracing.respond_to?(:active_trace)
+                trace = ::Datadog::Tracing.active_trace
+                trace_id = trace&.id&.to_s
+                return trace_id if trace_id && !trace_id.empty?
+              end
+              if ::Datadog::Tracing.respond_to?(:active_span)
+                span = ::Datadog::Tracing.active_span
+                trace_id = span&.trace_id&.to_s
+                return trace_id if trace_id && !trace_id.empty?
+              end
+            rescue StandardError
+              # Silently ignore Datadog errors
+            end
+          end
+
+          # 4. New Relic
+          if defined?(::NewRelic::Agent)
+            begin
+              if defined?(::NewRelic::Agent::Tracer) && ::NewRelic::Agent::Tracer.respond_to?(:current_trace_id)
+                trace_id = ::NewRelic::Agent::Tracer.current_trace_id
+                return trace_id if trace_id && !trace_id.empty?
+              end
+              if ::NewRelic::Agent.respond_to?(:linking_metadata)
+                metadata = ::NewRelic::Agent.linking_metadata
+                trace_id = metadata['trace.id'] || metadata[:trace_id]
+                return trace_id.to_s if trace_id && !trace_id.to_s.empty?
+              end
+            rescue StandardError
+              # Silently ignore New Relic errors
+            end
+          end
+
+          # 5. Elastic APM
+          if defined?(::ElasticAPM)
+            begin
+              if ::ElasticAPM.respond_to?(:current_transaction)
+                txn = ::ElasticAPM.current_transaction
+                trace_id = txn&.trace_id
+                return trace_id if trace_id && !trace_id.empty?
+              end
+            rescue StandardError
+              # Silently ignore Elastic APM errors
+            end
+          end
+
+          # 6. Java APMs (When running on JRuby / JVM)
+          if defined?(JRUBY_VERSION) || defined?(Java)
+            trace_id = extract_java_apm_trace_context
+            return trace_id if trace_id && !trace_id.empty?
+          end
+
+          nil
+        end
+
+        private
+
+        def extract_java_apm_trace_context
+          # 6a. Java OpenTelemetry
+          if defined?(Java::IoOpentelemetryApiTrace::Span)
+            begin
+              span = Java::IoOpentelemetryApiTrace::Span.current
+              if span
+                ctx = span.getSpanContext rescue nil
+                tid = ctx&.getTraceId
+                return tid.to_s if tid && tid.to_s != '00000000000000000000000000000000' && !tid.to_s.empty?
+              end
+            rescue StandardError
+            end
+          end
+
+          # 6b. Java Datadog
+          if defined?(Java::DatadogTraceApi::CorrelationIdentifier)
+            begin
+              tid = Java::DatadogTraceApi::CorrelationIdentifier.getTraceId
+              return tid.to_s if tid && tid.to_s != '0' && !tid.to_s.empty?
+            rescue StandardError
+            end
+          end
+
+          # 6c. Java New Relic
+          if defined?(Java::ComNewrelicApiAgent::NewRelic)
+            begin
+              tid = Java::ComNewrelicApiAgent::NewRelic.getAgent.getTraceMetadata.getTraceId rescue nil
+              return tid.to_s if tid && !tid.to_s.empty?
+            rescue StandardError
+            end
+          end
+
+          # 6d. Java Brave / Zipkin
+          if defined?(Java::Brave::Tracing)
+            begin
+              tracer = Java::Brave::Tracing.currentTracer rescue nil
+              span = tracer&.currentSpan rescue nil
+              tid = span&.context&.traceIdString rescue nil
+              return tid.to_s if tid && !tid.to_s.empty?
+            rescue StandardError
+            end
+          end
+
+          # 6e. Java SkyWalking
+          if defined?(Java::OrgApacheSkywalkingApmToolkitTrace::TraceContext)
+            begin
+              tid = Java::OrgApacheSkywalkingApmToolkitTrace::TraceContext.traceId rescue nil
+              return tid.to_s if tid && !tid.to_s.empty? && tid.to_s != 'N/A'
+            rescue StandardError
+            end
+          end
+
+          nil
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/hyperprobe/lambda.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module HyperProbe
+  module Lambda
+    class << self
+      def wrap(options = {}, &handler)
+        is_aws_lambda = !ENV['AWS_LAMBDA_FUNCTION_NAME'].nil?
+        is_local_emulator = ENV['IS_OFFLINE'] == 'true' || ENV['AWS_SAM_LOCAL'] == 'true'
+        is_ephemeral = (options[:is_lambda] || is_aws_lambda) && !is_local_emulator
+
+        # If running locally in emulator, standard background agent mode
+        unless is_ephemeral
+          HyperProbe.start(options)
+          return handler
+        end
+
+        # Ephemeral Lambda wrapper
+        lambda do |event:, context:|
+          unless HyperProbe.instance
+            HyperProbe.start(options.merge(is_lambda: true))
+          end
+
+          agent = HyperProbe.instance
+          is_active = agent && !agent.agent_disabled?
+
+          if is_active
+            remaining_ms = context.respond_to?(:get_remaining_time_in_millis) ? context.get_remaining_time_in_millis : nil
+            sync_timeout_ms = options[:lambda_sync_timeout_ms] || 2000
+
+            if remaining_ms
+              dynamic_budget = (remaining_ms * 0.2).to_i
+              if dynamic_budget < 100
+                sync_timeout_ms = 0
+              else
+                sync_timeout_ms = [sync_timeout_ms, dynamic_budget].min
+              end
+            end
+
+            if sync_timeout_ms.positive?
+              begin
+                agent.force_sync(sync_timeout_ms / 1000.0)
+              rescue StandardError => e
+                warn "[HyperProbe Lambda] Failed to sync probes: #{e.message}"
+              end
+            end
+          end
+
+          begin
+            if handler.parameters.length == 1
+              handler.call(event)
+            else
+              handler.call(event: event, context: context)
+            end
+          ensure
+            if is_active
+              remaining_ms = context.respond_to?(:get_remaining_time_in_millis) ? context.get_remaining_time_in_millis : 0
+              flush_timeout_ms = options[:flush_timeout_ms] || 1500
+
+              if remaining_ms && remaining_ms > 500
+                flush_timeout_ms = [remaining_ms - 200, flush_timeout_ms].min
+              end
+
+              if remaining_ms > 500 || !context.respond_to?(:get_remaining_time_in_millis)
+                begin
+                  agent.force_flush(flush_timeout_ms / 1000.0)
+                rescue StandardError => e
+                  warn "[HyperProbe Lambda] Failed to flush telemetry: #{e.message}"
+                end
+              else
+                warn '[HyperProbe Lambda] Aborting snapshot flush to prevent Lambda timeout.'
+              end
+            end
+          end
+        end
+      end
+
+      def stop
+        agent = HyperProbe.instance
+        if agent && !agent.agent_disabled?
+          begin
+            agent.force_flush(1.0)
+          rescue StandardError
+            # Best effort
+          end
+        end
+        HyperProbe.shutdown
+      end
+    end
+  end
+end