sqreen 1.18.3.beta1 → 1.18.3.beta2

data/lib/sqreen/js/thread_local_exec_js_runnable.rb

@@ -0,0 +1,47 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.com/terms.html
+
+# TODO: => Sqreen::JS:ExecJS
+
+require 'sqreen/js/executable_js'
+
+module Sqreen
+  module Js
+    class ThreadLocalExecJsRunnable < ExecutableJs
+      def initialize(code)
+        @code = code
+        @tl_key = "SQREEN_EXECJS_CONTEXT_#{object_id}".freeze
+        @runtimes = [] # place where to keep strong references
+        @runtimes_mutex = Mutex.new
+      end
+
+      def run_js_cb(cbname, _budget, arguments)
+        tl_exec_js_runnable.call(cbname, *arguments)
+      end
+
+      def with_runtimes_mutex
+        @runtimes_mutex.synchronize { yield }
+      end
+
+      private
+
+      def dispose_from_dead_threads
+        with_runtimes_mutex do
+          @runtimes.delete_if { |th, _runtime| !th.alive? }
+        end
+      end
+
+      def tl_exec_js_runnable
+        runnable = Thread.current[@tl_key]
+        return runnable if runnable && runnable.weakref_alive?
+
+        dispose_from_dead_threads
+        runtime = ExecJS.compile(@code)
+        with_runtimes_mutex do
+          @runtimes << [Thread.current, runtime]
+        end
+        Thread.current[@tl_key] = WeakRef.new(runtime)
+      end
+    end
+  end
+end

data/lib/sqreen/log.rb

@@ -1,207 +1,27 @@
 # Copyright (c) 2015 Sqreen. All Rights Reserved.
 # Please refer to our terms for more information: https://www.sqreen.com/terms.html
 
-require 'logger'
-require 'singleton'
-
 require 'sqreen/performance_notifications/log'
 require 'sqreen/performance_notifications/log_performance'
 require 'sqreen/configuration'
 
+require 'sqreen/logger'
+require 'sqreen/deferred_logger'
+
+# TODO: fold into Sqreen::Logger
+
 module Sqreen
   def self.log_init
-    @logger = Logger.new(
+    @logger = Sqreen::Logger.new(
       Sqreen.config_get(:log_level).to_s.upcase,
       Sqreen.config_get(:log_location)
     )
-    DeferredLogger.instance.flush_to(@logger.instance_eval { @logger })
+    Sqreen::DeferredLogger.instance.flush_to(@logger.instance_eval { @logger })
   rescue => e
     warn "Sqreen logger exception: #{e}"
   end
 
   def self::log
-    @logger || DeferredLogger.instance
-  end
-
-  # Ruby default formatter modified to display current thread_id
-  class FormatterWithTid
-    Format = "%s, [%s#%d.%s] %5s -- %s: %s\n".freeze
-    DatetimeFormat = '%Y-%m-%dT%H:%M:%S.%6N '.freeze
-
-    attr_accessor :datetime_format
-
-    def initialize
-      @datetime_format = nil
-    end
-
-    def call(severity, time, progname, msg)
-      format(Format,
-             severity[0..0], format_datetime(time), $$,
-             Thread.current.object_id.to_s(36),
-             severity, progname, msg2str(msg)
-            )
-    end
-
-    private
-
-    def format_datetime(time)
-      time.strftime(DatetimeFormat)
-    end
-
-    def msg2str(msg)
-      case msg
-      when ::String
-        msg
-      when ::Exception
-        "#{msg.message} (#{msg.class})\n" << (msg.backtrace || []).join("\n")
-      else
-        msg.inspect
-      end
-    end
-  end
-
-  # Wrapper class for sqreen logging
-  class Logger
-    SEVERITY_TO_METHOD = ::Logger::Severity.constants.each_with_object({}) do |s, h|
-      h[::Logger::Severity.const_get(s)] = s.downcase
-    end
-
-    def initialize(desired_level, log_location, force_logger = nil)
-      if force_logger
-        @logger = force_logger
-      else
-        init_logger_output(log_location)
-      end
-      init_log_level(desired_level)
-      enforce_log_format(@logger)
-      create_error_logger
-    end
-
-    def debug(msg = nil, &block)
-      @logger.debug(msg, &block)
-    end
-
-    def info(msg = nil, &block)
-      @logger.info(msg, &block)
-    end
-
-    def warn(msg = nil, &block)
-      @logger.warn(msg, &block)
-    end
-
-    def error(msg = nil, &block)
-      @error_logger.error(msg, &block)
-      @logger.error(msg, &block)
-    end
-
-    def add(severity, msg = nil, &block)
-      send(SEVERITY_TO_METHOD[severity], msg, &block)
-    end
-
-    protected
-
-    def init_logger_output(path)
-      path = File.expand_path(path)
-      if File.writable?(path) || File.writable?(File.dirname(path))
-        @logger = ::Logger.new(path)
-      else
-        @logger = ::Logger.new(STDOUT)
-        @logger.info("Cannot access #{path} for writing. Defaulting to stdout")
-      end
-    rescue => e
-      @logger = ::Logger.new(STDOUT)
-      @logger.error('Got error while trying to setting logger up, '\
-                    "falling back to stdout #{e.inspect}")
-    end
-
-    def init_log_level(level)
-      log_level = ::Logger.const_get(level)
-      @logger.level = log_level
-      Sqreen::PerformanceNotifications::Log.enable if level == 'DEBUG'
-      return if level != 'DEBUG' && !Sqreen.config_get(:report_perf)
-      Sqreen::PerformanceNotifications::LogPerformance.enable
-    end
-
-    def create_error_logger
-      @error_logger = Kernel.const_defined?('MiniTest') ? NullLogger.instance : ::Logger.new(STDERR)
-      enforce_log_format(@error_logger)
-    end
-
-    def enforce_log_format(logger)
-      logger.formatter = FormatterWithTid.new
-    end
-  end
-
-  class NullLogger
-    include Singleton
-
-    def debug(_msg = nil); end
-
-    def info(_msg = nil); end
-
-    def warn(_msg = nil); end
-
-    def error(_msg = nil); end
-
-    def fatal(_msg = nil); end
-
-    def add(_severity, _msg = nil); end
-
-    def formatter=(_); end
-  end
-
-  class DeferredLogger
-    include Singleton
-
-    def initialize
-      @buffer = StringIO.new
-      @logger = ::Logger.new(@buffer)
-    end
-
-    def debug(msg = nil, &block)
-      @logger.debug(msg, &block)
-    end
-
-    def info(msg = nil, &block)
-      @logger.info(msg, &block)
-    end
-
-    def warn(msg = nil, &block)
-      @logger.warn(msg, &block)
-    end
-
-    def error(msg = nil, &block)
-      @logger.error(msg, &block)
-    end
-
-    def fatal(msg = nil, &block)
-      @logger.error(msg, &block)
-    end
-
-    def add(severity, msg = nil, &block)
-      send(Sqreen::Logger::SEVERITY_TO_METHOD[severity], msg, &block)
-    end
-
-    def formatter=(value)
-      @logger.formatter = value
-    end
-
-    def flush_to(logger)
-      logger.instance_eval { @logdev }.write(read).tap { reset }
-    end
-
-    private
-
-    def read
-      @buffer.rewind
-      @buffer.read
-    end
-
-    def reset
-      buffer = StringIO.new
-      logger = ::Logger.new(buffer)
-      logger.formatter = @logger.formatter
-      @buffer, @logger = buffer, logger
-    end
+    @logger || Sqreen::DeferredLogger.instance
   end
 end

data/lib/sqreen/logger.rb

@@ -0,0 +1,83 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.com/terms.html
+
+require 'logger'
+require 'sqreen/log'
+require 'sqreen/formatter_with_tid'
+require 'sqreen/null_logger'
+
+# TODO: inherit from ::Logger
+
+module Sqreen
+  # Wrapper class for sqreen logging
+  class Logger
+    SEVERITY_TO_METHOD = ::Logger::Severity.constants.each_with_object({}) do |s, h|
+      h[::Logger::Severity.const_get(s)] = s.downcase
+    end
+
+    def initialize(desired_level, log_location, force_logger = nil)
+      if force_logger
+        @logger = force_logger
+      else
+        init_logger_output(log_location)
+      end
+      init_log_level(desired_level)
+      enforce_log_format(@logger)
+      create_error_logger
+    end
+
+    def debug(msg = nil, &block)
+      @logger.debug(msg, &block)
+    end
+
+    def info(msg = nil, &block)
+      @logger.info(msg, &block)
+    end
+
+    def warn(msg = nil, &block)
+      @logger.warn(msg, &block)
+    end
+
+    def error(msg = nil, &block)
+      @error_logger.error(msg, &block)
+      @logger.error(msg, &block)
+    end
+
+    def add(severity, msg = nil, &block)
+      send(SEVERITY_TO_METHOD[severity], msg, &block)
+    end
+
+    protected
+
+    def init_logger_output(path)
+      path = File.expand_path(path)
+      if File.writable?(path) || File.writable?(File.dirname(path))
+        @logger = ::Logger.new(path)
+      else
+        @logger = ::Logger.new(STDOUT)
+        @logger.info("Cannot access #{path} for writing. Defaulting to stdout")
+      end
+    rescue StandardError => e
+      @logger = ::Logger.new(STDOUT)
+      @logger.error('Got error while trying to setting logger up, '\
+                    "falling back to stdout #{e.inspect}")
+    end
+
+    def init_log_level(level)
+      log_level = ::Logger.const_get(level)
+      @logger.level = log_level
+      Sqreen::PerformanceNotifications::Log.enable if level == 'DEBUG'
+      return if level != 'DEBUG' && !Sqreen.config_get(:report_perf)
+      Sqreen::PerformanceNotifications::LogPerformance.enable
+    end
+
+    def create_error_logger
+      @error_logger = Kernel.const_defined?('MiniTest') ? NullLogger.instance : ::Logger.new(STDERR)
+      enforce_log_format(@error_logger)
+    end
+
+    def enforce_log_format(logger)
+      logger.formatter = Sqreen::FormatterWithTid.new
+    end
+  end
+end

data/lib/sqreen/metrics_store.rb

@@ -1,23 +1,15 @@
 # Copyright (c) 2015 Sqreen. All Rights Reserved.
 # Please refer to our terms for more information: https://www.sqreen.com/terms.html
 
-require 'sqreen/exception'
 require 'sqreen/metrics'
 require 'sqreen/mono_time'
+require 'sqreen/metrics_store/unknown_metric'
+require 'sqreen/metrics_store/unregistered_metric'
+require 'sqreen/metrics_store/already_registered_metric'
 
 module Sqreen
   # This store and register metrics
   class MetricsStore
-    # When a metric is not yet created
-    class UnregisteredMetric < Sqreen::Exception
-    end
-    # When the metric is unknown
-    class UnknownMetric < Sqreen::Exception
-    end
-    # When this name as already been declared with another kind
-    class AlreadyRegisteredMetric < Sqreen::Exception
-    end
-
     # definition keys
     NAME_KEY = 'name'.freeze
     KIND_KEY = 'kind'.freeze

data/lib/sqreen/metrics_store/already_registered_metric.rb

@@ -0,0 +1,11 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.com/terms.html
+
+require 'sqreen/exception'
+
+module Sqreen
+  class MetricsStore
+    class AlreadyRegisteredMetric < Sqreen::Exception
+    end
+  end
+end

data/lib/sqreen/metrics_store/unknown_metric.rb

@@ -0,0 +1,11 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.com/terms.html
+
+require 'sqreen/exception'
+
+module Sqreen
+  class MetricsStore
+    class UnknownMetric < Sqreen::Exception
+    end
+  end
+end

data/lib/sqreen/metrics_store/unregistered_metric.rb

@@ -0,0 +1,11 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.com/terms.html
+
+require 'sqreen/exception'
+
+module Sqreen
+  class MetricsStore
+    class UnregisteredMetric < Sqreen::Exception
+    end
+  end
+end

data/lib/sqreen/middleware.rb

@@ -11,48 +11,4 @@ module Sqreen
       @app.call(env)
     end
   end
-
-  class ErrorHandlingMiddleware
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      @app.call(env)
-    rescue => e
-      sqreen_attack = nil
-      if e.is_a?(Sqreen::AttackBlocked)
-        sqreen_attack = e
-      elsif e.respond_to?(:original_exception) &&
-                            e.original_exception.is_a?(Sqreen::AttackBlocked)
-        sqreen_attack = e.original_exception
-      end
-
-      if sqreen_attack && sqreen_attack.redirect_url
-        return [303, { 'Location' => sqreen_attack.redirect_url }, ['']]
-      else
-        raise
-      end
-    end
-  end
-
-  class RailsMiddleware
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      @app.call(env)
-    end
-  end
-
-  class SinatraMiddleware
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      @app.call(env)
-    end
-  end
 end