sqreen 1.15.0-java → 1.15.5-java

data/lib/sqreen/rules_callbacks/run_block_user_actions.rb

@@ -14,7 +14,7 @@ module Sqreen
       end
 
       def post(_retval, _inst, args, _budget = nil)
-        actions = actions_repo[Sqreen::Actions::BlockUser]
+        actions = actions_repo.get('block_user', args[@auth_keys_idx])
 
         actions.each do |action|
           res = action.run args[@auth_keys_idx]

data/lib/sqreen/rules_callbacks/run_req_start_actions.rb

@@ -9,6 +9,8 @@ module Sqreen
   module Rules
     # Runs actions concerned with whether the request ought to be served
     class RunReqStartActions < FrameworkCB
+      PRIORITY = 95
+
       def initialize(framework)
         if defined?(Sqreen::Frameworks::SinatraFramework) &&
            framework.is_a?(Sqreen::Frameworks::SinatraFramework)
@@ -30,13 +32,17 @@ module Sqreen
         framework && !framework.whitelisted_match.nil?
       end
 
+      def priority
+        PRIORITY
+      end
+
       def pre(_inst, _args, _budget = nil, &_block)
         return unless framework
         ip = framework.client_ip
         return unless ip
 
-        actions = actions_repo[Sqreen::Actions::BlockIp] +
-                  actions_repo[Sqreen::Actions::RedirectIp]
+        actions = actions_repo.get(Sqreen::Actions::BlockIp, ip) +
+                  actions_repo.get(Sqreen::Actions::RedirectIp, ip)
 
         actions.each do |act|
           res = run_client_ip_action(act, ip)

data/lib/sqreen/runner.rb

@@ -214,9 +214,10 @@ module Sqreen
     def config_binned_metrics(level, base, factor, base_pct, factor_pct)
       level = level.to_i
       if level <= 0
-        Sqreen.log.debug('Disabling binned metrics')
+        Sqreen.log.info('Disabling binned metrics')
         PerformanceNotifications::BinnedMetrics.disable
       else
+        Sqreen.log.info('Enabling binned metrics')
         Sqreen.log.warn("Unknown value for perf_level: #{level}. Treating as 1") unless level == 1
         PerformanceNotifications::BinnedMetrics.enable(
           metrics_engine, PERF_METRICS_PERIOD, base.to_f, factor.to_f, base_pct.to_f, factor_pct.to_f
@@ -352,9 +353,10 @@ module Sqreen
 
     def aggregate_observations
       q = Sqreen.observations_queue
+      conv = Sqreen.time - Time.now.utc.to_f
       q.size.times do
         cat, key, obs, t = q.pop
-        metrics_engine.update(cat, t, key, obs)
+        metrics_engine.update(cat, conv + t.utc.to_f, key, obs)
       end
     end
 
@@ -445,9 +447,14 @@ module Sqreen
     def load_actions(hashes)
       unsupported = Set.new
 
+      repos = Sqreen::Actions::Repository.instance
+      repos.clear
+
       actions = hashes.map do |h|
         begin
-          Sqreen::Actions.deserialize_action(h)
+          act = Sqreen::Actions.deserialize_action(h)
+          repos.add h['parameters'], act
+          act
         rescue Sqreen::Actions::UnknownActionType => e
           Sqreen.log.warn("Unsupported action type: #{e.action_type}")
           unsupported << e.action_type
@@ -458,11 +465,7 @@ module Sqreen
       end
 
       actions = actions.reject(&:nil?)
-      Sqreen.log.debug("Will add #{actions.size} valid actions")
-
-      repos = Sqreen::Actions::Repository.instance
-      repos.clear
-      actions.each { |action| repos << action }
+      Sqreen.log.debug("Added #{actions.size} valid actions")
 
       unsupported
     end

data/lib/sqreen/sdk.rb

@@ -24,7 +24,13 @@ module Sqreen
     end
 
     def track(event_name, options = {})
-      return unless Sqreen.framework
+      unless Sqreen.framework
+        Sqreen.log.warn("Ignored track call (event #{event_name}) due to framework absence")
+        return
+      end
+
+      Sqreen.log.debug { "Sqreen.track() call (event #{event_name}, options #{options})" }
+
       if event_name.start_with? SDK_RESERVED_PREFIX
         Sqreen.log.warn("Event names starting with '#{SDK_RESERVED_PREFIX}' " \
                         'are reserved. Event ignored.')

data/lib/sqreen/session.rb

@@ -292,6 +292,10 @@ module Sqreen
         h[EVENT_TYPE_KEY] = event_kind(event)
         h
       end
+      Sqreen.log.debug do
+        tally = Hash[events.group_by(&:class).map{ |k,v| [k, v.count] }]
+        "Doing batch with the following tally of event types: #{tally}"
+      end
       resilient_post(BATCH_KEY, BATCH_KEY => batch)
     end
 

data/lib/sqreen/trie.rb

@@ -0,0 +1,274 @@
+require 'ipaddr'
+
+module Sqreen
+  Trie = Struct.new(:head, :num_active_nodes, :family) do
+    attr_reader :max_num_bits
+
+    def initialize(*args)
+      super
+      self.family ||= Socket::AF_INET
+      self.num_active_nodes = 0
+      @max_num_bits = family == Socket::AF_INET ? 32 : 128
+    end
+
+    def insert(arg_prefix)
+      raise 'family mismatch' if arg_prefix.family != family
+
+      if head.nil?
+        node = Node.new(
+            arg_prefix.bitlen, # bit
+            arg_prefix,
+            nil, nil, nil, #l , r, parent
+        )
+        self.head = node
+        self.num_active_nodes += 1
+        return node
+      end
+
+      arg_addr = arg_prefix.address
+      arg_bitlen = arg_prefix.bitlen
+      xcur = self.head
+
+      # descend until we find the end of the tree or go past the
+      # bitlen of the prefix we're adding
+      while xcur.bit < arg_bitlen || xcur.empty?
+        if bit_set?(arg_addr, xcur.bit)
+          break if xcur.r.nil?
+          xcur = xcur.r
+        else
+          break if xcur.l.nil?
+          xcur = xcur.l
+        end
+      end
+
+      trie_addr = xcur.prefix.address
+
+      # find first bit that differs between addr and trie_addr
+      cmp_bit_end = [arg_bitlen, xcur.bit].min # after last to be compared
+
+      differ_bit = (0...cmp_bit_end).find do |i|
+        bit_set?(arg_addr, i) ^ bit_set?(trie_addr, i)
+      end
+      differ_bit = cmp_bit_end if differ_bit.nil?
+
+      # go up till we find the parent before the bits differ
+      xparent = xcur.parent
+      while !xparent.nil? && xparent.bit >= differ_bit
+        xcur = xparent
+        xparent = xcur.parent
+      end
+
+      # case 1: replace current node's prefix
+      if differ_bit == arg_bitlen && xcur.bit == arg_bitlen
+        xcur.prefix = arg_prefix
+        return xcur
+      end
+
+      xnew = Node.new(arg_prefix.bitlen, arg_prefix, nil, nil, nil)
+      self.num_active_nodes += 1
+
+      # case 2: append below found node
+      if xcur.bit == differ_bit
+        xnew.parent = xcur
+        if bit_set?(arg_addr, xcur.bit)
+          xcur.r = xnew
+        else
+          xcur.l = xnew
+        end
+
+        return xnew
+      end
+
+      # case 3: take place of found node
+      if arg_bitlen == differ_bit
+        if bit_set?(trie_addr, arg_bitlen)
+          xnew.r = xcur
+        else
+          xnew.l = xcur
+        end
+
+        xnew.parent = xcur.parent
+
+        if xcur.parent.nil?
+          self.head = xnew
+        elsif xcur.parent.r.equal?(xcur)
+          xcur.parent.r = xnew
+        else
+          xcur.parent.l = xnew
+        end
+
+        xcur.parent = xnew
+
+        return xnew
+      end
+
+      # case 4: need to add intermediate node to be parent of the
+      #         both xnew and xcur
+
+      # last arg is the parent of the new node
+      xglue = Node.new(differ_bit, nil, nil, nil, xcur.parent)
+      self.num_active_nodes += 1
+
+      if bit_set?(arg_addr, differ_bit)
+        xglue.r = xnew
+        xglue.l = xcur
+      else
+        xglue.r = xcur
+        xglue.l = xnew
+      end
+
+      xnew.parent = xglue
+
+      if xcur.parent.nil?
+        self.head = xglue
+      elsif xcur.equal?(xcur.parent.r)
+        xcur.parent.r = xglue
+      else
+        xcur.parent.l = xglue
+      end
+
+      xcur.parent = xglue
+
+      xnew
+    end
+
+    # generate pdf with `dot -Tpdf <input> > foo.pdf`
+    def to_dot(header = true)
+      res = ''
+      res = "graph trie {\n" if header
+
+      next_name = 'a'
+      obj_label_map = Hash.new do |h, k|
+        h[k] = next_name
+        next_name = next_name.next
+        h[k]
+      end
+
+      head.walk(max_num_bits, true) do |node|
+        node_name = obj_label_map[node.object_id]
+
+        if node.empty?
+          label = "<glue at bit #{node.bit}>"
+        else
+          ip_addr = IPAddr.new(node.prefix.address, node.prefix.family)
+          label = ip_addr.to_s + '/' + node.prefix.bitlen.to_s
+        end
+        res += "#{node_name} [label=\"#{label}\"]\n"
+        res += "#{node_name} -- #{obj_label_map[node.l.object_id]} [label=\"l\"]\n" if node.l
+        res += "#{node_name} -- #{obj_label_map[node.r.object_id]} [label=\"r\"]\n" if node.r
+      end
+      res += "}\n" if header
+      res
+    end
+
+    def search_best(addr, family)
+      nodes = search_common(addr, family)
+      for i in (nodes.size - 1).downto(0)
+        xcur = nodes[i]
+        return node_to_ip_addr(xcur) if xcur.prefix.matches?(addr, family)
+      end
+
+      nil
+    end
+
+    def search_matching(addr, family)
+      nodes = search_common(addr, family)
+      nodes.select { |xcur| xcur.prefix.matches?(addr, family) }
+           .map { |xcur| node_to_ip_addr(xcur) }
+           .reverse
+    end
+
+    private
+
+    def node_to_ip_addr(node)
+      ret = IPAddr.new(node.prefix.address, node.prefix.family)
+      ret.singleton_class.send(:define_method, :data) { node.prefix.data }
+      ret
+    end
+
+    def bit_set?(addr, i)
+      addr[max_num_bits - i - 1] == 1
+    end
+
+    def search_common(addr, family)
+      raise 'family mismatch' unless family == self.family
+
+      xstack = []
+
+      xcur = head
+      while !xcur.nil?
+        unless xcur.empty?
+          xstack << xcur
+        end
+
+        xcur = bit_set?(addr, xcur.bit) ? xcur.r : xcur.l
+      end
+
+      xstack
+    end
+  end
+
+  Prefix = Struct.new(:family, :bitlen, :address, :data) do # addr is integer
+    def initialize(*args)
+      super
+      raise ArgumentError, 'no family given' unless family
+      raise ArgumentError, 'no bitlen given' unless bitlen
+      raise ArgumentError, 'no address given' unless address
+    end
+
+    def matches?(addr, family)
+      raise 'family mismatch' unless family == self.family
+      shift_amount = (family == Socket::AF_INET ? 32 : 128) - self.bitlen
+      (addr ^ self.address) >> shift_amount == 0
+    end
+  end
+
+  def Prefix.from_str(str, data = nil)
+    ip_addr = IPAddr.new(str)
+    if str =~ /\/(\d+)$/
+      bitlen = $~[1].to_i
+    else
+      bitlen = ip_addr.family == Socket::AF_INET6 ? 128 : 32
+    end
+    Prefix.new(ip_addr.family, bitlen, ip_addr.to_i, data)
+  end
+
+  # bit starts at 0 (most significant)
+  Node = Struct.new(:bit, :prefix, :l, :r, :parent) do
+    def initialize(*args)
+      super
+      raise ArgumentError, 'no bit given' if bit.nil?
+    end
+
+    def empty?
+      prefix.nil?
+    end
+
+    # cover the whole tree
+    def walk(max_bits, empty_nodes = false)
+      xstack = Array.new(max_bits + 1)
+      sidx = 0 # stack index
+      xhead = self
+      xcur = xhead
+      while !xcur.nil?
+        yield xcur unless xcur.empty? && !empty_nodes
+
+        if xcur.l
+          if xcur.r
+            xstack[sidx] = xcur.r
+            sidx += 1
+          end
+          xcur = xcur.l
+        elsif xcur.r
+          xcur = xcur.r
+        elsif sidx.nonzero?
+          sidx -= 1
+          xcur = xstack[sidx]
+        else
+          xcur = nil
+        end
+      end
+    end
+  end
+
+end

data/lib/sqreen/version.rb

@@ -1,5 +1,5 @@
 # Copyright (c) 2015 Sqreen. All Rights Reserved.
 # Please refer to our terms for more information: https://www.sqreen.io/terms.html
 module Sqreen
-  VERSION = '1.15.0'.freeze
+  VERSION = '1.15.5'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sqreen
 version: !ruby/object:Gem::Version
-  version: 1.15.0
+  version: 1.15.5
 platform: java
 authors:
 - Sqreen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-10-24 00:00:00.000000000 Z
+date: 2018-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -89,6 +89,7 @@ files:
 - lib/sqreen/metrics/sum.rb
 - lib/sqreen/metrics_store.rb
 - lib/sqreen/middleware.rb
+- lib/sqreen/mono_time.rb
 - lib/sqreen/payload_creator.rb
 - lib/sqreen/performance_notifications.rb
 - lib/sqreen/performance_notifications/binned_metrics.rb
@@ -131,6 +132,7 @@ files:
 - lib/sqreen/session.rb
 - lib/sqreen/shared_storage.rb
 - lib/sqreen/shared_storage23.rb
+- lib/sqreen/trie.rb
 - lib/sqreen/version.rb
 homepage: https://www.sqreen.io/
 licenses: []