sqreen 1.20.4 → 1.21.0.beta1

data/lib/sqreen/ecosystem/loggable.rb

@@ -0,0 +1,13 @@
+require 'sqreen/ecosystem/dispatch_table'
+
+module Sqreen
+  module Ecosystem
+    module Loggable
+      private
+
+      def logger
+        DispatchTable.fetch_logger.call
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/module_api.rb

@@ -0,0 +1,30 @@
+require 'sqreen/ecosystem/loggable'
+
+module Sqreen
+  module Ecosystem
+    # The API that the transport/tracing modules are written against
+    module ModuleApi
+      TRACE_ID_HEADER = 'X-Sqreen-Trace-Identifier'.freeze
+      TRACE_ID_ENV_KEY = 'HTTP_X_SQREEN_TRACE_IDENTIFIER'.freeze
+
+      Loggable = Sqreen::Ecosystem::Loggable
+
+      module ClassMethods
+        attr_writer :module_name
+
+        def module_name
+          if instance_variable_defined?(:@module_name)
+            @module_name
+          else
+            # to snake case
+            @module_name = to_s.sub(/.*::/, '').gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+          end
+        end
+      end
+
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/module_api/event_listener.rb

@@ -0,0 +1,18 @@
+require 'sqreen/ecosystem/dispatch_table'
+
+module Sqreen
+  module Ecosystem
+    module ModuleApi
+      module EventListener
+        private
+
+        # XXX: callbacks need to be wrapped in order ot handle
+        # perfcap, exceptions, and maybe other concerns applying
+        # across the board
+        def on_request_start(&cb)
+          DispatchTable.add_request_start_listener.call(cb)
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/module_api/instrumentation.rb

@@ -0,0 +1,23 @@
+require 'sqreen/ecosystem/module_api'
+
+module Sqreen
+  module Ecosystem
+    module ModuleApi
+      module Instrumentation
+        def self.included(mod)
+          mod.send :include, ModuleApi unless mod.ancestors.include?(ModuleApi)
+        end
+
+        private
+
+        # Just forwards the call to the instrumentation service
+        # @param [String] method
+        # @param [Hash{Symbol=>Proc}] advice keys are one of: :before, :after,
+        #                             :raised,
+        def instrument(method, advice)
+          DispatchTable.instrument.call(self.class.module_name, method, advice)
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/module_api/signal_producer.rb

@@ -0,0 +1,26 @@
+require 'sqreen/ecosystem/dispatch_table'
+require 'sqreen/ecosystem/module_api/transaction_storage'
+
+module Sqreen
+  module Ecosystem
+    module ModuleApi
+      module SignalProducer
+        include TransactionStorage
+
+        # for injection
+        attr_writer :tracing_id_producer
+
+        private
+
+        def create_tracing_id
+          @tracing_id_producer.call
+        end
+
+        # @param [Sqreen::Kit::Signals::Signal] signal
+        def submit_signal(signal)
+          DispatchTable.consume_signal.call(signal)
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/module_api/tracing_push_down.rb

@@ -0,0 +1,34 @@
+require 'sqreen/ecosystem/loggable'
+require 'sqreen/ecosystem/tracing/sampling_configuration'
+
+module Sqreen
+  module Ecosystem
+    module ModuleApi
+      module TracingPushDown
+        include Loggable
+
+        # method for ecosystem to inject the config
+        # @param [Sqreen::Ecosystem::SamplingConfiguration]
+        attr_writer :sampling_config
+
+        private
+
+        def should_sample?(scope)
+          unless @sampling_config
+            logger.debug { "Scope #{scope} is disabled because tracing hasn't been enabled yet" }
+            return
+          end
+
+          result = @sampling_config.should_sample?(scope)
+          if result
+            logger.debug { "Will sample scope #{scope}. Sampling line: #{result}" }
+          else
+            logger.debug { "Will NOT sample scope #{scope}" }
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/module_api/transaction_storage.rb

@@ -0,0 +1,71 @@
+require 'sqreen/ecosystem/transaction_storage'
+require 'sqreen/ecosystem/loggable'
+
+module Sqreen
+  module Ecosystem
+    module ModuleApi
+      module TransactionStorage
+        class TxLocalVariables
+          class << self
+            class << self
+              include Sqreen::Ecosystem::Loggable
+
+              private
+
+              def attr_reader(attr, _opts = {})
+                define_method attr do
+                  tx_storage = Ecosystem::TransactionStorage.fetch_thread_local
+                  return unless tx_storage
+                  tx_storage[attr]
+                end
+              end
+
+              def attr_accessor(attr, opts = {})
+                # reader
+                attr_reader attr, opts
+
+                # writer (2 variants)
+                do_assign = proc do |value|
+                  tx_storage = Ecosystem::TransactionStorage.fetch_thread_local
+                  unless tx_storage
+                    logger.debug do
+                      "Assignment of tx local attribute #{attr} to #{value} has no effect"
+                    end
+                    return
+                  end
+
+                  tx_storage[attr] = value
+                end
+
+                if opts.fetch(:allow_overwrite, false)
+                  define "#{attr}=", &do_assign
+                else
+                  define_method "#{attr}=" do |value|
+                    cur = public_send(attr)
+                    unless cur.nil?
+                      raise "Cannot override value of #{attr} from #{cur} with #{value}"
+                    end
+
+                    do_assign.call(value)
+                  end
+                end
+              end
+            end # TxLocalVariables.singleton_class.singleton_class
+
+            # usage:
+            # attr_reader :xxx
+
+            # in the future, we'll possibly need to expose the full
+            # TransactionStorage to the modules, at least if we don't
+            # opt for a more structured fashion of data exchange between
+            # the modules.
+          end # TxLocalVariables.singleton_class
+        end # TxLocalVariables
+
+        def tx_local_vars
+          TxLocalVariables
+        end
+      end # TransactionStorage module
+    end
+  end
+end

data/lib/sqreen/ecosystem/module_registry.rb

@@ -0,0 +1,39 @@
+require 'sqreen/ecosystem/loggable'
+
+module Sqreen
+  module Ecosystem
+    class ModuleRegistry
+      include Sqreen::Ecosystem::Loggable
+
+      def initialize
+        @mods = []
+      end
+
+      def register(mod)
+        @mods << mod
+      end
+
+      def init_all
+        logger.info { "Initializing #{@mods.size} ecosystem modules" }
+        each_module do |mod|
+          logger.debug { "Initializing module with type #{mod.class}" }
+          mod.setup
+        end
+      end
+
+      def destroy_all
+        # not implemented
+      end
+
+      # @param [Class] type
+      def each_module(type = nil, &block)
+        selected_mods = type ? (@mods.select { |mod| mod.is_a?(type) }) : @mods
+        if block_given?
+          selected_mods.each(&block)
+        else
+          selected_mods.each
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/redis/redis_connection.rb

@@ -0,0 +1,35 @@
+require 'sqreen/ecosystem/tracing/signals/tracing_client'
+require 'sqreen/ecosystem/module_api/signal_producer'
+
+module Sqreen
+  module Ecosystem
+    module Redis
+      class RedisConnection
+        include ModuleApi::SignalProducer
+        include ModuleApi::TracingPushDown
+        include ModuleApi::Instrumentation
+
+        def setup
+          instrument 'Redis::Connection::TCPSocket#connect',
+                     before: method(:before_advice)
+        end
+
+        private
+
+        def before_advice
+          return unless should_sample?('client')
+
+          host = call.args[0]
+          port = call.args[1]
+
+          signal = Sqreen::Kit::Signals::Specialized::TracingClient.new
+          signal.payload = Sqreen::Kit::Signals::Specialized::TracingClient::Payload.new(
+            transport: 'redis',
+            host: host, port: port
+          )
+          submit_signal signal
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+require 'thread' # for Mutex
+require 'singleton'
+require 'sqreen/ecosystem/loggable'
+
+# see https://github.com/sqreen/TechDoc/blob/master/content/specs/spec000024-sampling.md
+
+module Sqreen
+  module Ecosystem
+    module Tracing
+      class Sampler
+        # @param [Array<Hash{String=>Object}>] definition
+        def initialize(definition)
+          @lines = definition.map { |h| Line.new(h) }
+        end
+
+        def should_sample?
+          line = @lines.find(&:triggers?)
+          line ? line.saved_definition : false
+        end
+
+        class Line
+          include Loggable
+
+          attr_reader :saved_definition
+
+          # @param [Hash{String=>Object}] definition
+          def initialize(definition)
+            @saved_definition = definition
+            @primitives = []
+
+            unknown = definition.keys - PRIMITIVES_MAP.keys
+            unless unknown.empty?
+              logger.warn "Unknown primitives: #{unknown}"
+              @primitives << AlwaysFalsePrimitive.instance
+              return
+            end
+
+            PRIMITIVES_MAP.each do |key, prim_class|
+              next unless definition[key]
+              @primitives << prim_class.new(definition[key])
+            end
+            # if @primitives is empty the line will always
+            # return true: [].all?(&:triggers?) is true
+          end
+
+          def triggers?
+            @primitives.all?(&:triggers?)
+          end
+        end
+
+        class AlwaysFalsePrimitive
+          include Singleton
+
+          def triggers?
+            false
+          end
+        end
+
+        class CallsPrimitive
+          def initialize(calls_period)
+            @calls_period = calls_period
+            @count = 0
+            @mutex = Mutex.new
+          end
+
+          def triggers?
+            prev_count = nil
+            @mutex.synchronize do
+              prev_count = @count
+              @count += 1
+            end
+
+            (prev_count % @calls_period).zero?
+          end
+        end
+
+        class RandomPrimitive
+          def initialize(probability)
+            @probability = probability
+          end
+
+          def triggers?
+            @probability >= rand
+          end
+        end
+
+        class MaxDurationMinutesPrimitive
+          def initialize(time_in_minutes)
+            @deadline = Sqreen.time + time_in_minutes * 60
+            @passed = false # no locking needed
+          end
+
+          def triggers?
+            return false if @passed
+            if Sqreen.time > @deadline
+              @passed = true
+              return false
+            end
+            true
+          end
+        end
+
+        class TargetPerMinutePrimitive
+          def initialize(max_calls)
+            @max_calls = max_calls
+            @minute_last_call = cur_minute
+            @calls_accumulated = 0
+            @mutex = Mutex.new
+          end
+
+          def triggers?
+            this_minute = cur_minute
+            calls_cur_minute = @mutex.synchronize do
+              if @minute_last_call == this_minute
+                @calls_accumulated += 1
+              else
+                @minute_last_call = this_minute
+                @calls_accumulated = 1
+              end
+            end
+
+            calls_cur_minute <= @max_calls
+          end
+
+          private
+
+          def cur_minute
+            (Sqreen.time / 60).floor
+          end
+        end
+
+        class MaxCallsPrimitive
+          def initialize(max_calls)
+            @max_calls = max_calls
+            @disabled = false # to avoid lock
+            @mutex = Mutex.new
+            @num_calls = 0
+          end
+
+          def triggers?
+            return false if @disabled
+            num_calls = @mutex.synchronize do
+              @num_calls += 1
+            end
+
+            num_calls <= @max_calls
+          end
+        end
+
+        PRIMITIVES_MAP = {
+          "calls"                => CallsPrimitive,
+          "random"               => RandomPrimitive,
+          "max_duration_minutes" => MaxDurationMinutesPrimitive,
+          "target_per_minute"    => TargetPerMinutePrimitive,
+          "max_calls"            => MaxCallsPrimitive,
+        }.freeze
+      end
+    end
+  end
+end