sqreen 1.20.4 → 1.21.0.beta1

data/lib/sqreen/ecosystem/tracing/sampling_configuration.rb

@@ -0,0 +1,150 @@
+require 'thread'
+require 'sqreen/ecosystem/loggable'
+require 'sqreen/ecosystem/tracing/sampler'
+
+module Sqreen
+  module Ecosystem
+    module Tracing
+      # tracing sampling configuration, as specified by the 2nd argument of the
+      # tracing_enable command.
+      # See https://github.com/sqreen/TechDoc/blob/master/content/specs/spec000025-enabling-tracing.md
+      class SamplingConfiguration
+        include Loggable
+
+        DEFAULT_SCOPE = '*'.freeze
+
+        def initialize(sampling_config)
+          @sampling_config = sampling_config
+          @samplers = {}
+          @samplers_virtual = build_virtual_holders(sampling_config)
+        end
+
+        # @param [String] scope either the scope or the part behind @ in a virtual scope
+        # @param [String] qualifier the part after @ in a virtual scope or nil
+        def should_sample?(scope, qualifier = nil)
+          if qualifier
+            fetch_sampler_virtual(scope, qualifier).should_sample?
+          else
+            fetch_sampler(scope).should_sample?
+          end
+        end
+
+        def forget_virtual_scope(scope, qualifier)
+          holder = @samplers_virtual[scope]
+          return unless holder.delete!(qualifier)
+        end
+
+        private
+
+        def fetch_sampler_virtual(scope, qualifier)
+          holder = @samplers_virtual[scope]
+
+          # no virtual scope configured, fallback to plain scope
+          return fetch_sampler(scope) unless holder
+
+          holder[qualifier]
+        end
+
+        def fetch_sampler(scope)
+          sampler = @samplers[scope]
+          return sampler if sampler
+
+          cfg = @sampling_config[scope] || @sampling_config[DEFAULT_SCOPE]
+          if cfg
+            @samplers[scope] = SamplingConfiguration.build_sampler(scope, cfg)
+          else
+            logger.info { "Disabling scope #{scope} due to its not being configured" }
+            @samplers[scope] = DisabledScopeSampler
+          end
+        end
+
+        def build_virtual_holders(sampling_config)
+          Hash[
+            sampling_config
+            .select { |scope, _cfg| scope.end_with?('@*') }
+            .map do |scope, cfg|
+              parent = scope[0...-2] # remove trailing @*
+              [parent, VirtualScopesHolder.new(parent, cfg)]
+            end
+          ]
+        end
+
+        class << self
+          include Loggable
+
+          def build_sampler(scope, cfg)
+            do_build_sampler(cfg['enabled'], cfg['sampling'] || [{}])
+          rescue StandardError => e
+            logger.warn "Invalid sampling configuration for #{scope}: #{e.inspect}"
+            logger.debug { e.backtrace }
+            DisabledScopeSampler
+          end
+
+          private
+
+          def do_build_sampler(enabled, sampling)
+            if enabled
+              Sampler.new(sampling)
+            else
+              logger.debug { "Disabling scope #{scope}" }
+              DisabledScopeSampler
+            end
+          end
+        end
+      end
+
+      class VirtualScopesHolder
+        include Loggable
+
+        MAX_VIRTUAL_SCOPES = 120
+        DISCARD_SIZE = 20
+
+        def initialize(parent, cfg)
+          @parent = parent
+          @cfg = cfg
+          @virtual_scopes = {}
+          @mutex = Mutex.new
+        end
+
+        def [](qualifier)
+          return false unless @cfg['enabled']
+
+          @mutex.synchronize do
+            sampler = @virtual_scopes[qualifier]
+            return sampler if sampler
+
+            @virtual_scopes[qualifier] = create_virtual(qualifier)
+          end
+        end
+
+        def delete!(qualifier)
+          @virtual_scopes.delete(qualifier)
+        end
+
+        private
+
+        def create_virtual(qualifier)
+          discard if @virtual_scopes.size >= MAX_VIRTUAL_SCOPES
+
+          @virtual_scopes[qualifier] =
+            SamplingConfiguration.build_sampler("#{@parent}@#{qualifier}", @cfg)
+        end
+
+        def discard
+          logger.info { "Discarding excess virtual scopes for scope '#{@parent}'" }
+          discard_keys = @virtual_scopes.keys.sample(DISCARD_SIZE)
+          @virtual_scopes.delete_if { |k, _v| discard_keys.include? k }
+        end
+      end
+
+      # fake sampler that always returns false
+      class DisabledScopeSampler
+        class << self
+          def should_sample?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/tracing/signals/tracing_client.rb

@@ -0,0 +1,53 @@
+require 'sqreen/kit/configuration'
+require 'sqreen/kit/signals/point'
+require 'sqreen/kit/signals/dto_helper'
+
+# reference: https://github.com/sqreen/SignalsSchemas/blob/master/schemas/payload/tracing/client-2020-04-21/schema.cue
+
+module Sqreen
+  module Ecosystem
+    module Tracing
+      module Signals
+      end
+    end
+  end
+end
+
+class Sqreen::Ecosystem::Tracing::Signals::TracingClient < Sqreen::Kit::Signals::Point
+  readonly_attrs :payload_schema, :source, :signal_name
+
+  def initialize(values = {})
+    self.payload_schema = Payload::SCHEMA_VERSION
+    self.source = Sqreen::Kit::Configuration.default_source
+    self.signal_name = 'tracing.client'
+    self.time = values[:time] || Time.now
+    super
+  end
+
+  def payload=(payload)
+    unless payload.is_a?(Payload)
+      raise ArgumentError, "Payload should be a #{Payload}"
+    end
+    super
+  end
+
+  class Payload
+    include Sqreen::Kit::Signals::DtoHelper
+
+    add_mandatory_attrs :transport, :host
+
+    SCHEMA_VERSION = 'tracing/client-2020-04-21'.freeze
+
+    # @return [Symbol]
+    attr_accessor :transport
+
+    # @return [String]
+    attr_accessor :host
+
+    # @return [String]
+    attr_accessor :ip
+
+    # @return [String]
+    attr_accessor :tracing_identifier
+  end
+end

data/lib/sqreen/ecosystem/tracing/signals/tracing_server.rb

@@ -0,0 +1,53 @@
+require 'sqreen/kit/configuration'
+require 'sqreen/kit/signals/point'
+require 'sqreen/kit/signals/dto_helper'
+
+# reference: https://github.com/sqreen/SignalsSchemas/blob/master/schemas/payload/tracing/server-2020-04-21/schema.cue
+
+module Sqreen
+  module Ecosystem
+    module Tracing
+      module Signals
+      end
+    end
+  end
+end
+
+class Sqreen::Ecosystem::Tracing::Signals::TracingServer < Sqreen::Kit::Signals::Point
+  readonly_attrs :payload_schema, :source, :signal_name
+
+  def initialize(values = {})
+    self.payload_schema = Payload::SCHEMA_VERSION
+    self.source = Sqreen::Kit::Configuration.default_source
+    self.signal_name = 'tracing.server'
+    self.time = values[:time] || Time.now
+    super
+  end
+
+  def payload=(payload)
+    unless payload.is_a?(Payload)
+      raise ArgumentError, "Payload should be a #{Payload}"
+    end
+    super
+  end
+
+  class Payload
+    include Sqreen::Kit::Signals::DtoHelper
+
+    add_mandatory_attrs :transport, :client_ip
+
+    SCHEMA_VERSION = 'tracing/server-2020-04-21'.freeze
+
+    # @return [Symbol]
+    attr_accessor :transport
+
+    # @return [String]
+    attr_accessor :client_ip
+
+    # @return [Array<String>]
+    attr_accessor :previous_hops
+
+    # @return [String]
+    attr_accessor :tracing_identifier
+  end
+end

data/lib/sqreen/ecosystem/tracing_id_setup.rb

@@ -0,0 +1,34 @@
+require 'sqreen/ecosystem/module_registry'
+require 'sqreen/ecosystem/transaction_storage'
+require 'sqreen/ecosystem/module_api/signal_producer'
+
+module Sqreen
+  module Ecosystem
+    class TracingIdSetup
+      # @param [Sqreen::Ecosystem::ModuleRegistry] registry
+      def initialize(registry)
+        @registry = registry
+        @tracing_id_prefix = nil
+      end
+
+      def setup_modules
+        inject_out_of_tx_tracing_id_gen
+      end
+
+      attr_writer :tracing_id_prefix
+
+      private
+
+      def inject_out_of_tx_tracing_id_gen
+        @registry.each_module(Sqreen::Ecosystem::ModuleApi::SignalProducer) do |mod|
+          mod.tracing_id_producer = method(:generate_tracing_id)
+        end
+      end
+
+      def generate_tracing_id
+        return nil unless @tracing_id_prefix
+        "#{@tracing_id_prefix}.#{SecureRandom.uuid}"
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/transaction_storage.rb

@@ -0,0 +1,64 @@
+require 'sqreen/ecosystem/loggable'
+
+module Sqreen
+  module Ecosystem
+    # The transaction storage is a mechanism for the modules to share
+    # request-scoped data with each other or to keep request-scoped objects
+    # themselves, although, for this last use case to be effective,
+    # propagation of request start/end events to the modules will likely be
+    # needed. A more generic notification of data availability to modules
+    # also may be needed in the future.
+    #
+    # This is not be used to share data with the Ecosystem client
+    #
+    # This class is not thread safe because it can call the lazy getter
+    # twice if [] is called concurrently.
+    class TransactionStorage
+      include Loggable
+
+      class << self
+        # @return [Sqreen::Ecosystem::TransactionStorage]
+        def create_thread_local
+          Thread.current[:tx_storage] = new
+        end
+
+        # @return [Sqreen::Ecosystem::TransactionStorage]
+        def fetch_thread_local
+          Thread.current[:tx_storage]
+        end
+
+        def destroy_thread_local
+          Thread.current[:tx_storage] = nil
+        end
+      end
+
+      def initialize
+        @values = {}
+        @values_lazy = {}
+      end
+
+      def []=(key, value)
+        @values[key] = value
+      end
+
+      def set_lazy(key, &block)
+        @values_lazy[key] = block
+      end
+
+      def [](key)
+        v = @values[key]
+        return v unless v.nil?
+
+        v = @values_lazy[key]
+        return nil if v.nil?
+
+        begin
+          @values[key] = v.call
+        rescue StandardError => e
+          logger.warn { "Error resolving key #{e} with lazy value: #{e.message}" }
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem_integration.rb

@@ -0,0 +1,70 @@
+require 'sqreen/log/loggable'
+require 'sqreen/ecosystem'
+require 'sqreen/ecosystem/dispatch_table'
+require 'sqreen/ecosystem_integration/instrumentation_service'
+require 'sqreen/ecosystem_integration/request_lifecycle_tracking'
+require 'sqreen/ecosystem_integration/signal_consumption'
+
+module Sqreen
+  # This class is the interface through which the agent interacts
+  # with the ecosystem.
+  #
+  # Other classes in the EcosystemIntegration module implement the
+  # functionality that the ecosystem requires in order to deliver
+  # data to the agent and to be informed by the agent of certain
+  # key events (see Sqreen::Ecosystem::DispatchTable).
+  class EcosystemIntegration
+    include Sqreen::Log::Loggable
+
+    # @param [Sqreen::Framework] framework
+    def initialize(framework, queue)
+      @framework = framework
+      @queue = queue
+      @request_lifecycle = RequestLifecycleTracking.new
+    end
+
+    def init
+      setup_dispatch_table
+      Ecosystem.init
+      logger.info 'Ecosystem successfully initialized'
+    rescue ::Exception => e # rubocop:disable Lint/RescueException
+      logger.warn { "Error initializing Ecosystem: #{e.message}" }
+      logger.debug { e.backtrace.map { |x| "  #{x}" }.join("\n") }
+    end
+
+    def disable
+      raise NotImplementedYet
+    end
+
+    def request_start(rack_request)
+      Ecosystem.start_transaction
+      @request_lifecycle.notify_request_start(rack_request)
+    end
+
+    def request_end
+      Ecosystem.end_transaction
+    end
+
+    def handle_tracing_command(trace_id_prefix, scopes_config)
+      Ecosystem.configure_sampling(trace_id_prefix, scopes_config)
+    end
+
+    private
+
+    def setup_dispatch_table
+      Ecosystem::DispatchTable.consume_signal =
+        create_signal_consumption.method(:consume_signal)
+
+      Ecosystem::DispatchTable.add_request_start_listener =
+        @request_lifecycle.method(:add_start_observer)
+
+      Ecosystem::DispatchTable.fetch_logger = lambda { logger }
+
+      Ecosystem::DispatchTable.instrument = InstrumentationService.method(:instrument)
+    end
+
+    def create_signal_consumption
+      SignalConsumption.new(@framework, @request_lifecycle, @queue)
+    end
+  end
+end

data/lib/sqreen/ecosystem_integration/around_callbacks.rb

@@ -0,0 +1,89 @@
+require 'sqreen/log/loggable'
+require 'sqreen/events/remote_exception'
+require 'sqreen/mono_time'
+
+module Sqreen
+  class EcosystemIntegration
+    module AroundCallbacks
+      class << self
+        include Log::Loggable::ClassMethods
+
+        # for instrumentation hooks
+        # instrumentation hooks already handle budgets, so nothing
+        # to do in that respect
+        def wrap_instrumentation_hook(module_name, action, callable)
+          perf_notif_name = "ecosystem_#{module_name}"
+
+          Proc.new do |*args|
+            begin
+              start = Sqreen.time
+              callable.call(*args)
+            rescue ::Exception => e # rubocop:disable Lint/RescueException
+              # 2) rescue exceptions
+              logger.warn { "Error in #{module_name}:#{action}: #{e.message}" }
+              logger.debug { e.backtrace.map { |x| "  #{x}" }.join("\n") }
+              Sqreen::RemoteException.record(e)
+            ensure
+              # 3) contribute to performance metrics
+              stop = Sqreen.time
+              Sqreen::PerformanceNotifications.notify(perf_notif_name, action, start, stop)
+            end # end proc
+          end # end begin
+        end
+
+        # XXX: not used yet
+        def wrap_generic_callback(module_name, action, callable)
+          timer_name = "ecosystem:#{module_name}@#{action}"
+          perf_notif_name = "ecosystem_#{module_name}"
+
+          Proc.new do |*args|
+            begin
+              req_storage = Thread.current[:sqreen_http_request]
+
+              timer = Graft::Timer.new(timer_name) do |t|
+                # this is an epilogue to measure()
+                req_storage && req_storage[:timed_hooks] << t
+              end
+
+              req_timer = nil
+              timer.measure do
+                # not in a request, no budget; call cb
+                next callable.call(*args) unless req_storage
+
+                # 1) budget enforcement
+                # skip callback if budget already expended
+                next if req_storage[:time_budget_expended]
+
+                budget = req_storage[:time_budget]
+                if budget
+                  req_timer = req_storage[:timer]
+                  remaining = budget - req_timer.elapsed
+                  unless remaining > 0
+                    req_storage[:time_budget_expended] = true
+                    next # skip callback
+                  end
+                end
+
+                callable.call(*args)
+              end
+            rescue ::Exception => e # rubocop:disable Lint/RescueException
+              # 2) rescue exceptions
+              logger.warn { "Error in #{module_name}:#{action}: #{e.message}" }
+              logger.debug { e.backtrace.map { |x| "  #{x}" }.join("\n") }
+              Sqreen::RemoteException.record(e)
+            ensure
+              # 3) contribute to performance metrics
+              if timer
+                req_timer.include_measurements(timer) if req_timer
+
+                Sqreen::PerformanceNotifications.notify(
+                  perf_notif_name, action, *timer.start_and_end
+                )
+              end
+            end # end begin
+          end # end proc
+        end
+      end
+    end
+  end
+end