sqreen 1.20.4-java → 1.21.0.beta3-java

data/lib/sqreen/graft/hook.rb

@@ -7,17 +7,21 @@ require 'sqreen/graft'
 require 'sqreen/graft/call'
 require 'sqreen/graft/callback'
 require 'sqreen/graft/hook_point'
+require 'sqreen/weave'
+require 'sqreen/runner' # Sqreen.queue
 
 module Sqreen
   module Graft
     class Hook
+      DEFAULT_STRATEGY = Sqreen::Graft::HookPoint::DEFAULT_STRATEGY
+
       @hooks = {}
 
-      def self.[](hook_point, strategy = :chain)
+      def self.[](hook_point, strategy = DEFAULT_STRATEGY)
         @hooks[hook_point] ||= new(hook_point, nil, strategy)
       end
 
-      def self.add(hook_point, strategy = :chain, &block)
+      def self.add(hook_point, strategy = DEFAULT_STRATEGY, &block)
         self[hook_point, strategy].add(&block)
       end
 
@@ -30,7 +34,7 @@ module Sqreen
 
       attr_reader :point
 
-      def initialize(hook_point, dependency_test = nil, strategy = :chain)
+      def initialize(hook_point, dependency_test = nil, strategy = DEFAULT_STRATEGY)
         @disabled = false
         @point = hook_point.is_a?(HookPoint) ? hook_point : HookPoint.new(hook_point, strategy)
         @before = []
@@ -134,6 +138,13 @@ module Sqreen
             request[:timed_callbacks] << t if request[:timed_level] >= 1
           end
         end
+        # very hacky, but the non-local control flow with throw-catch
+        # makes the solution non-obvious. needs to be revisited
+        conditions_passed_proc = proc do
+          if (request = Thread.current[:sqreen_http_request])
+            request[:timed_callbacks].last.conditions_passed = true
+          end
+        end
 
         Proc.new do |*args, &block|
           request = Thread.current[:sqreen_http_request]
@@ -181,18 +192,15 @@ module Sqreen
             # budget implies request
             # TODO: make budget depend on a generic context (currently "request")
             budget = request[:time_budget] if request
-            if budget
-              budget_threshold = request[:time_budget_threshold]
-              budget_ratio = request[:time_budget_ratio]
+            if request && (budget || request[:timed_level] >= 1)
               sqreen_timer = request[:sqreen_timer]
-              request_timer = request[:request_timer]
             end
 
             hooked_call = HookedCall.new(self, args)
 
             begin
               begin
-                sqreen_timer.start if budget
+                sqreen_timer.start if sqreen_timer
                 Thread.current[:sqreen_hook_entered] = true
 
                 # TODO: make Call have #ball to throw by cb
@@ -204,34 +212,34 @@ module Sqreen
                 # TODO: TimedHookCall TimedCallbackCall
                 # TODO: TimeBoundHookCall TimeBoundCallbackCall TimeBoundFlow?
 
-                request_elapsed = request_timer.elapsed if budget
-
                 hook.before.each do |c|
                   next if c.ignore && c.ignore.call
 
-                  if budget && !c.mandatory
-                    sqreen_elapsed = sqreen_timer.elapsed
-                    if budget_ratio && !request[:time_budget_expended]
-                      fixed_budget = budget_threshold
-                      proportional_budget = (request_elapsed - sqreen_elapsed) * budget_ratio
-                      remaining = (fixed_budget > proportional_budget ? fixed_budget : proportional_budget) - sqreen_elapsed
-                    else
-                      remaining = budget_threshold - sqreen_elapsed
-                    end
-                    unless remaining > 0
-                      request[:skipped_callbacks] << c
-                      request[:time_budget_expended] = true
-                      next
-                    end
+                  if budget && !c.mandatory && request[:time_budget_expended]
+                    request[:skipped_callbacks] << c
+                    next
                   end
 
+                  remaining = budget - sqreen_timer.elapsed if budget
+
+                  timer = nil
                   flow = catch(Ball.new) do |ball|
-                    Timer.new(c.name, &timed_callbacks_proc).measure(ignore: chrono) do
+                    timer = Timer.new(c.name, &timed_callbacks_proc)
+                    timer.measure(ignore: chrono) do
                       c.call(CallbackCall.new(c, remaining, hooked_call.instance, hooked_call.args_passed), ball)
                     end
                   end
 
+                  if budget && timer
+                    remaining -= timer.duration
+                    if remaining < 0.0
+                      request[:time_budget_expended]
+                      request[:overtime_cb] = c.name
+                    end
+                  end
+
                   next unless c.flow && flow.is_a?(Flow)
+                  conditions_passed_proc[] if flow.passed_conditions?
                   hooked_call.raise = flow.raise and hooked_call.raising = true if flow.raise?
                   hooked_call.args_pass = flow.args and hooked_call.args_passing = true if flow.args?
                   hooked_call.return = flow.return and hooked_call.returning = true if flow.return?
@@ -246,7 +254,7 @@ module Sqreen
               return hooked_call.return if hooked_call.returning
             ensure
               Thread.current[:sqreen_hook_entered] = false
-              sqreen_timer.stop if budget
+              sqreen_timer.stop if sqreen_timer
             end unless hook.before.empty?
 
             begin
@@ -259,41 +267,41 @@ module Sqreen
               end
             rescue ::Exception => e # rubocop:disable Lint/RescueException
               begin
-                sqreen_timer.start if budget
+                sqreen_timer.start if sqreen_timer
                 Thread.current[:sqreen_hook_entered] = true
                 hooked_call.raised = e
 
                 logger.debug { "[#{Process.pid}] Hook #{hook.point} disabled:#{hook.disabled?} exception:#{e}" } if logger_debug
                 raise if hook.raised.empty?
 
-                request_elapsed = request_timer.elapsed if budget
-
                 hook.raised.each do |c|
                   next if c.ignore && c.ignore.call
 
-                  if budget && !c.mandatory
-                    sqreen_elapsed = sqreen_timer.elapsed
-                    if budget_ratio && !request[:time_budget_expended]
-                      fixed_budget = budget_threshold
-                      proportional_budget = (request_elapsed - sqreen_elapsed) * budget_ratio
-                      remaining = (fixed_budget > proportional_budget ? fixed_budget : proportional_budget) - sqreen_elapsed
-                    else
-                      remaining = budget_threshold - sqreen_elapsed
-                    end
-                    unless remaining > 0
-                      request[:skipped_callbacks] << c
-                      request[:time_budget_expended] = true
-                      next
-                    end
+                  if budget && !c.mandatory && request[:time_budget_expended]
+                    request[:skipped_callbacks] << c
+                    next
                   end
 
+                  remaining = budget - sqreen_timer.elapsed if budget
+
+                  timer = nil
                   flow = catch(Ball.new) do |ball|
-                    Timer.new(c.name, &timed_callbacks_proc).measure(ignore: chrono) do
+                    timer = Timer.new(c.name, &timed_callbacks_proc)
+                    timer.measure(ignore: chrono) do
                       c.call(CallbackCall.new(c, remaining, hooked_call.instance, hooked_call.args_passing ? hooked_call.args_pass : hooked_call.args_passed, hooked_call.raised), ball)
                     end
                   end
 
+                  if budget && timer
+                    remaining -= timer.duration
+                    if remaining < 0.0
+                      request[:time_budget_expended]
+                      request[:overtime_cb] = c.name
+                    end
+                  end
+
                   next unless c.flow && flow.is_a?(Flow)
+                  conditions_passed_proc[] if flow.passed_conditions?
                   hooked_call.raise = flow.raise and hooked_call.raising = true if flow.raise?
                   hooked_call.return = flow.return and hooked_call.returning = true if flow.return?
                   hooked_call.retrying = true if flow.retry?
@@ -310,40 +318,40 @@ module Sqreen
               raise
             else
               begin
-                sqreen_timer.start if budget
+                sqreen_timer.start if sqreen_timer
                 Thread.current[:sqreen_hook_entered] = true
 
                 # TODO: hooked_call.returning should be always false here?
                 return hooked_call.returning ? hooked_call.return : hooked_call.returned if hook.after.empty?
 
-                request_elapsed = request_timer.elapsed if budget
-
                 hook.after.each do |c|
                   next if c.ignore && c.ignore.call
 
-                  if budget && !c.mandatory
-                    sqreen_elapsed = sqreen_timer.elapsed
-                    if budget_ratio && !request[:time_budget_expended]
-                      fixed_budget = budget_threshold
-                      proportional_budget = (request_elapsed - sqreen_elapsed) * budget_ratio
-                      remaining = (fixed_budget > proportional_budget ? fixed_budget : proportional_budget) - sqreen_elapsed
-                    else
-                      remaining = budget_threshold - sqreen_elapsed
-                    end
-                    unless remaining > 0
-                      request[:skipped_callbacks] << c
-                      request[:time_budget_expended] = true
-                      next
-                    end
+                  if budget && !c.mandatory && request[:time_budget_expended]
+                    request[:skipped_callbacks] << c
+                    next
                   end
 
+                  remaining = budget - sqreen_timer.elapsed if budget
+
+                  timer = nil
                   flow = catch(Ball.new) do |ball|
-                    Timer.new(c.name, &timed_callbacks_proc).measure(ignore: chrono) do
+                    timer = Timer.new(c.name, &timed_callbacks_proc)
+                    timer.measure(ignore: chrono) do
                       c.call(CallbackCall.new(c, remaining, hooked_call.instance, hooked_call.args_passing ? hooked_call.args_pass : hooked_call.args_passed, nil, hooked_call.returned), ball)
                     end
                   end
 
+                  if budget && timer
+                    remaining -= timer.duration
+                    if remaining < 0.0
+                      request[:time_budget_expended]
+                      request[:overtime_cb] = c.name
+                    end
+                  end
+
                   next unless c.flow && flow.is_a?(Flow)
+                  conditions_passed_proc[] if flow.passed_conditions?
                   hooked_call.raise = flow.raise and hooked_call.raising = true if flow.raise?
                   hooked_call.return = flow.return and hooked_call.returning = true if flow.return?
                   break if flow.break?
@@ -371,36 +379,38 @@ module Sqreen
                 hook.ensured.each do |c|
                   next if c.ignore && c.ignore.call
 
-                  if budget && !c.mandatory
-                    sqreen_elapsed = sqreen_timer.elapsed
-                    if budget_ratio && !request[:time_budget_expended]
-                      fixed_budget = budget_threshold
-                      proportional_budget = (request_elapsed - sqreen_elapsed) * budget_ratio
-                      remaining = (fixed_budget > proportional_budget ? fixed_budget : proportional_budget) - sqreen_elapsed
-                    else
-                      remaining = budget_threshold - sqreen_elapsed
-                    end
-                    unless remaining > 0
-                      request[:skipped_callbacks] << c
-                      request[:time_budget_expended] = true
-                      next
-                    end
+                  if budget && !c.mandatory && request[:time_budget_expended]
+                    request[:skipped_callbacks] << c
+                    next
                   end
 
+                  remaining = budget - sqreen_timer.elapsed if budget
+
+                  timer = nil
                   flow = catch(Ball.new) do |ball|
-                    Timer.new(c.name, &timed_callbacks_proc).measure(ignore: chrono) do
+                    timer = Timer.new(c.name, &timed_callbacks_proc)
+                    timer.measure(ignore: chrono) do
                       c.call(CallbackCall.new(c, remaining, hooked_call.instance, hooked_call.args_passing ? hooked_call.args_pass : hooked_call.args_passed, nil, hooked_call.returned), ball)
                     end
                   end
 
+                  if budget && timer
+                    remaining -= timer.duration
+                    if remaining < 0.0
+                      request[:time_budget_expended]
+                      request[:overtime_cb] = c.name
+                    end
+                  end
+
                   next unless c.flow && flow.is_a?(Flow)
+                  conditions_passed_proc[] if flow.passed_conditions?
                   hooked_call.raise = flow.raise and hooked_call.raising = true if flow.raise?
                   hooked_call.return = flow.return and hooked_call.returning = true if flow.return?
                   break if flow.break?
                 end unless hook.ensured.empty? || hook.disabled?
 
                 Thread.current[:sqreen_hook_entered] = false
-                sqreen_timer.stop if budget
+                sqreen_timer.stop if sqreen_timer
               rescue StandardError => e
                 Sqreen::Weave.logger.debug { "exception:#{e.class} message:'#{e.message}' location:\"#{e.backtrace[0]}\"" }
                 Sqreen::RemoteException.record(e) if Sqreen.queue

data/lib/sqreen/graft/hook_point.rb

@@ -23,6 +23,8 @@ module Sqreen
     end
 
     class HookPoint
+      DEFAULT_STRATEGY = Module.respond_to?(:prepend) ? :prepend : :chain
+
       def self.parse(hook_point)
         klass_name, separator, method_name = hook_point.split(/(\#|\.)/, 2)
 
@@ -36,7 +38,7 @@ module Sqreen
 
       attr_reader :klass_name, :method_kind, :method_name
 
-      def initialize(hook_point, strategy = :chain)
+      def initialize(hook_point, strategy = DEFAULT_STRATEGY)
         @klass_name, @method_kind, @method_name = Sqreen::Graft::HookPoint.parse(hook_point)
         @strategy = strategy
       end
@@ -177,23 +179,30 @@ module Sqreen
 
       private
 
-      def prepend(key)
+      def hook_spot(key)
         target = klass_method? ? klass.singleton_class : klass
         mod = target.ancestors.each { |e| break if e == target; break(e) if e.class == HookSpot && e.key == key }
+        raise "Inconsistency detected: #{target} missing from its own ancestors" if mod.is_a?(Array)
+
+        [target, mod]
+      end
+
+      def prepend(key)
+        target, mod = hook_spot(key)
+
         mod ||= HookSpot.new(key)
+
         target.instance_eval { prepend(mod) }
       end
 
       def prepended?(key)
-        target = klass_method? ? klass.singleton_class : klass
-        mod = target.ancestors.each { |e| break if e == target; break(e) if e.class == HookSpot && e.key == key }
+        _, mod = hook_spot(key)
 
         mod != nil
       end
 
       def overridden?(key)
-        target = klass_method? ? klass.singleton_class : klass
-        mod = target.ancestors.each { |e| break if e == target; break(e) if e.class == HookSpot && e.key == key }
+        _, mod = hook_spot(key)
 
         (mod.instance_methods(false) + mod.protected_instance_methods(false) + mod.private_instance_methods(false)).include?(method_name)
       end
@@ -202,8 +211,7 @@ module Sqreen
         hook_point = self
         method_name = @method_name
 
-        target = klass_method? ? klass.singleton_class : klass
-        mod = target.ancestors.each { |e| break if e == target; break(e) if e.class == HookSpot && e.key == key }
+        _, mod = hook_spot(key)
 
         mod.instance_eval do
           if hook_point.private_method?
@@ -221,8 +229,7 @@ module Sqreen
       def unoverride(key)
         method_name = @method_name
 
-        target = klass_method? ? klass.singleton_class : klass
-        mod = target.ancestors.each { |e| break if e == target; break(e) if e.class == HookSpot && e.key == key }
+        _, mod = hook_spot(key)
 
         mod.instance_eval { remove_method(method_name) }
       end

data/lib/sqreen/legacy/old_event_submission_strategy.rb

@@ -56,6 +56,12 @@ module Sqreen
               when AggregatedMetric
                 logger.warn "Aggregated metric event in non-signal mode. Signals disabled at runtime?"
                 next
+              when Sqreen::Kit::Signals::Signal
+                logger.warn "Signal event in non-signal mode"
+                next
+              when Sqreen::Kit::Signals::Trace
+                logger.warn "Trace event in non-signal mode"
+                next
               when Attack # in practice only found inside req rec
                 EventToHash.convert_attack event
               when RemoteException
@@ -73,7 +79,7 @@ module Sqreen
           tally = Hash[events.group_by(&:class).map { |k, v| [k, v.count] }]
           "Doing batch with the following tally of event types: #{tally}"
         end
-        post('batch', { batch: batch }, {}, RETRY_MANY)
+        post('batch', { batch: batch.compact }, {}, RETRY_MANY)
       end
 
       private

data/lib/sqreen/metrics/req_detailed.rb

@@ -0,0 +1,41 @@
+require 'base64'
+require 'sqreen/mono_time'
+require 'sqreen/metrics/base'
+begin
+  require 'sq_detailed_metrics'
+rescue LoadError => _e # rubocop:disable Lint/HandleExceptions
+end
+
+module Sqreen
+  module Metric
+    class ReqDetailed < Base
+      attr_reader :num_requests
+
+      def initialize(opts = {})
+        raise 'SqDetailedMetrics unavailable' unless defined?(SqDetailedMetrics)
+        super(opts)
+        @coll = SqDetailedMetrics::RequestCollection.new
+        @start_time = Sqreen.time
+        @num_requests = 0
+      end
+
+      # @param [SqDetailedMetrics::Request] value
+      def update(_key, value)
+        @coll << value
+        @num_requests += 1
+      end
+
+      def next_sample(time)
+        data = @coll.serialize
+        @num_requests = 0
+        return nil unless data
+
+        {
+          OBSERVATION_KEY => { 'v1' => Base64.strict_encode64(data) },
+          START_KEY => @start_time,
+          FINISH_KEY => (@start_time = time),
+        }
+      end
+    end
+  end
+end

data/lib/sqreen/metrics.rb

@@ -7,3 +7,4 @@ require 'sqreen/metrics/collect'
 require 'sqreen/metrics/average'
 require 'sqreen/metrics/sum'
 require 'sqreen/metrics/binning'
+require 'sqreen/metrics/req_detailed'

data/lib/sqreen/remote_command.rb

@@ -23,6 +23,7 @@ module Sqreen
       :ips_whitelist => :change_whitelisted_ips,
       :get_bundle => :upload_bundle,
       :performance_budget => :change_performance_budget,
+      :tracing_enable => :tracing_enable,
     }.freeze
 
     attr_reader :uuid
@@ -40,6 +41,8 @@ module Sqreen
       begin
         output = runner.send(KNOWN_COMMANDS[@name], *@params, context_infos)
       rescue => e
+        Sqreen.log.warn { "Command failed with #{e}" }
+        Sqreen.log.debug { e.backtrace.map { |x| "  #{x}" }.join("\n") }
         Sqreen::RemoteException.record(e)
         return { :status => false, :reason => "error: #{e.inspect}" }
       end

data/lib/sqreen/rules/rule_cb.rb

@@ -90,9 +90,9 @@ module Sqreen
         framework.observe(:sqreen_exceptions, payload)
       end
 
-      # Recommend taking an action (optionnally adding more data/context)
+      # Recommend taking an action (optionally adding more data/context)
       #
-      # This will format the requested action and optionnally
+      # This will format the requested action and optionally
       # override it if it should not be taken (should not block for example)
       def advise_action(action, additional_data = {})
         return if action.nil? && additional_data.empty?

data/lib/sqreen/runner.rb

@@ -14,6 +14,7 @@ require 'sqreen/log'
 require 'sqreen/agent_message'
 require 'sqreen/rules'
 require 'sqreen/session'
+require 'sqreen/version'
 require 'sqreen/remote_command'
 require 'sqreen/capped_queue'
 require 'sqreen/metrics_store'
@@ -26,6 +27,7 @@ require 'sqreen/legacy/instrumentation'
 require 'sqreen/call_countable'
 require 'sqreen/weave/legacy/instrumentation'
 require 'sqreen/kit/configuration'
+require 'sqreen/ecosystem_integration'
 
 module Sqreen
   @features = {}
@@ -52,10 +54,6 @@ module Sqreen
       @queue ||= CappedQueue.new(MAX_QUEUE_LENGTH)
     end
 
-    def update_queue(queue)
-      @queue = queue
-    end
-
     def observations_queue
       @observations_queue ||= CappedQueue.new(MAX_OBS_QUEUE_LENGTH)
     end
@@ -104,8 +102,8 @@ module Sqreen
     # we may want to do that in a thread in order to prevent delaying app
     # startup
     # set_at_exit do not place a global at_exit (used for testing)
+    # @param [Sqreen::Frameworks::GenericFramework] framework
     def initialize(configuration, framework, set_at_exit = true, session_class = Sqreen::Session)
-      Sqreen.update_queue(CappedQueue.new(MAX_QUEUE_LENGTH))
       @logged_out_tried = false
       @configuration = configuration
       @framework = framework
@@ -132,6 +130,7 @@ module Sqreen
       Sqreen::Kit::Configuration.ingestion_url = chosen_endpoints.ingestion.url
       Sqreen::Kit::Configuration.certificate_store = chosen_endpoints.ingestion.ca_store
       Sqreen::Kit::Configuration.proxy_url = @proxy_url
+      Sqreen::Kit::Configuration.default_source = "sqreen:agent:ruby:#{Sqreen::VERSION}"
 
       register_exit_cb if set_at_exit
 
@@ -142,7 +141,12 @@ module Sqreen
       end
 
       if @configuration.get(:weave) || needs_weave.call
-        @instrumenter = Sqreen::Weave::Legacy::Instrumentation.new(metrics_engine)
+        # XXX: don't get updated
+        opts = {
+          perf_req_metrics_max_reqs: Sqreen.features['perf_req_metrics_max_reqs'],
+          perf_req_metrics_period: Sqreen.features['perf_req_metrics_period'],
+        }
+        @instrumenter = Sqreen::Weave::Legacy::Instrumentation.new(metrics_engine, opts)
       else
         @instrumenter = Sqreen::Legacy::Instrumentation.new(metrics_engine)
       end
@@ -168,6 +172,12 @@ module Sqreen
       end
       self.features = wanted_features
 
+      @ecosystem_integration = EcosystemIntegration.new(framework,
+                                                        Sqreen.queue,
+                                                        create_binning_metric_proc)
+      framework.req_start_cb = @ecosystem_integration.method(:request_start)
+      framework.req_end_cb = @ecosystem_integration.method(:request_end)
+
       # Ensure a deliverer is there unless features have set it first
       self.deliverer ||= Deliveries::Simple.new(session)
       context_infos = {}
@@ -268,6 +278,10 @@ module Sqreen
       rulespack_id, rules = load_rules(context_infos)
       @framework.instrument_when_ready!(instrumenter, rules)
       Sqreen.log.info 'Instrumentation set up'
+
+      # XXX: ecosystem instrumentation should likely be deferred
+      #      the same way the rest might be
+      @ecosystem_integration.init unless Sqreen.features['disable_ecosystem']
       rulespack_id.to_s
     end
 
@@ -392,15 +406,8 @@ module Sqreen
         prev = Sqreen::Weave::Budget.current
         prev = prev.to_h if prev
 
-        budget_s = budget.to_f / 1000 if budget
-
-        feature = features['performance_budget']
-        if feature
-          budget_s = feature['threshold'] if feature.key?('threshold')
-          ratio = feature['ratio'] if feature.key?('ratio')
-        end
-
-        Sqreen::Weave::Budget.update(threshold: budget_s, ratio: ratio)
+        budget_s = budget.to_f / 1000.0 if budget
+        Sqreen::Weave::Budget.update(threshold: budget_s)
       else
         prev = Sqreen.performance_budget
         Sqreen.update_performance_budget(budget)
@@ -409,6 +416,13 @@ module Sqreen
       { :was => prev }
     end
 
+    # @param [String] tracing_id_prefix
+    # @param [Array<Hash{String=>Object}>] sampling_config
+    def tracing_enable(tracing_id_prefix, sampling_config, _context_infos = {})
+      @ecosystem_integration.handle_tracing_command(tracing_id_prefix, sampling_config)
+      { status: true }
+    end
+
     def upload_bundle(_context_infos = {})
       t = Time.now
       session.post_bundle(RuntimeInfos.dependencies_signature, RuntimeInfos.dependencies)
@@ -541,6 +555,21 @@ module Sqreen
 
     private
 
+    def create_binning_metric_proc
+      lambda do |metric_name|
+        return if @metrics_engine.metric?(metric_name)
+        metrics_engine.create_metric(
+          'name' => metric_name,
+          'kind' => 'Binning',
+          'period' => Sqreen.features['performance_metrics_period'] || 60,
+          'options' => {
+            'base' => Sqreen.features['perf_base'] || PerformanceNotifications::BinnedMetrics::DEFAULT_PERF_BASE,
+            'factor' => Sqreen.features['perf_unit'] || PerformanceNotifications::BinnedMetrics::DEFAULT_PERF_UNIT,
+          },
+        )
+      end
+    end
+
     def post_endpoint_testing_msgs(chosen_endpoints)
       chosen_endpoints.messages.each do |msg|
         session.post_agent_message(@framework, msg)

data/lib/sqreen/session.rb

@@ -249,8 +249,10 @@ module Sqreen
       end
       Sqreen.log.info 'Login success.'
       @session_id = res['session_id']
+
       Kit::Configuration.session_key = @session_id
       Kit.reset
+
       Sqreen.log.debug { "received session_id #{@session_id}" }
       Sqreen.logged_in = true
       res

data/lib/sqreen/signals/conversions.rb

@@ -118,6 +118,7 @@ module Sqreen
           signals += req_rec.processed_sdk_calls
                             .select { |h| h[:name] == :track }
                             .map { |h| convert_track(h) }
+          signals += (observed[:signals] || [])
 
           trace = Kit::Signals::Specialized::HttpTrace.new(
             actor: Kit::Signals::Actor.new(
@@ -137,7 +138,7 @@ module Sqreen
           trace
         end
 
-        # @param [Array<Sqreen::Kit::Signals::Signal|Sqreen::Kit::Signals::Trace>] batch
+        # @return [Array<Sqreen::Kit::Signals::Signal|Sqreen::Kit::Signals::Trace>]
         def convert_batch(batch)
           batch.map do |evt|
             case evt
@@ -147,6 +148,10 @@ module Sqreen
               convert_metric_sample(evt)
             when RequestRecord
               convert_req_record(evt)
+            when Sqreen::Kit::Signals::Signal
+              evt
+            when Sqreen::Kit::Signals::Trace
+              evt
             else
               raise NotImplementedError, "Unknown type of event in batch: #{evt}"
             end

data/lib/sqreen/version.rb

@@ -4,5 +4,5 @@
 # Please refer to our terms for more information: https://www.sqreen.com/terms.html
 
 module Sqreen
-  VERSION = '1.20.4'.freeze
+  VERSION = '1.21.0.beta3'.freeze
 end