sqreen 1.18.2-java → 1.18.3-java

data/lib/sqreen/js/mini_racer_executable_js.rb

@@ -0,0 +1,142 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.com/terms.html
+
+# TODO: => Sqreen::JS:MiniRacer
+# TODO: remove class vars
+
+require 'sqreen/log'
+
+module Sqreen
+  module Js
+    class MiniRacerExecutableJs < ExecutableJs
+      @@ctx_defined = false # rubocop:disable Style/ClassVars
+
+      def ctx_defined?
+        @@ctx_defined
+      end
+
+      def define_ctx!
+        @@ctx_defined = true # rubocop:disable Style/ClassVars
+      end
+
+      def initialize(pool, code, vendored)
+        @pool = pool
+        @code = code
+        @code_id = self.class.code_id(code)
+
+        @module = vendored ? Sqreen::MiniRacer : MiniRacer
+
+        mod = vendored ? Sqreen::MiniRacer : MiniRacer
+
+        return if ctx_defined?
+
+        self.class.define_sqreen_context(mod)
+        define_ctx!
+      end
+
+      def run_js_cb(cb_name, budget, arguments)
+        @pool.with_context do |ctx|
+          if ctx.code_failed?(@code_id)
+            Sqreen.log.debug do
+              "Skipping execution of callback #{cb_name} (code md5 #{@code_id})" \
+              " due to prev failure of definition evaluation"
+            end
+            return nil
+          end
+
+          ctx.add_code(@code_id, @code) unless ctx.code?(@code_id)
+
+          # mini_racer expects timeout to be in ms
+          ctx.timeout = budget ? budget * 1000.0 : nil
+          begin
+            ctx.call("sqreen_#{@code_id}_#{cb_name}", *arguments)
+          rescue @module::ScriptTerminatedError
+            Sqreen.log.debug "ScriptTerminatedError/#{cb_name}"
+            nil
+          end
+        end
+      end
+
+      def self.code_id(code)
+        Digest::MD5.hexdigest(code)
+      end
+
+      class << self
+        def define_sqreen_context(modoole)
+          # Context specialized for Sqreen usage
+          Sqreen::Js.const_set 'SqreenContext', Class.new(modoole.const_get('Context'))
+          SqreenContext.class_eval do
+            attr_accessor :gc_threshold_in_bytes
+            attr_accessor :gc_load
+            attr_writer   :timeout
+
+            def code?(code_id)
+              return false unless @code_ids
+              @code_ids.include?(code_id)
+            end
+
+            def code_failed?(code_id)
+              return false unless @failed_code_ids
+              @failed_code_ids.include?(code_id)
+            end
+
+            def add_code(code_id, code)
+              # It's important that the definition is run in its own scope (by executing it inside an anonymous function)
+              # Otherwise some auxiliary functions that the backend server sends will collide the name
+              # Because they're defined with `var`, running the definitions inside a function is enough
+              eval_unsafe "(function() { #{code} })()"
+              transf_global_funcs code_id
+              @code_ids ||= Set.new
+              @code_ids << code_id
+            rescue StandardError
+              @failed_code_ids ||= Set.new
+              @failed_code_ids << code_id
+              raise
+            end
+
+            def eval_unsafe(str, filename = nil, timeoutv = nil)
+              # Beware, timeout could be kept in the context
+              # if perf cap is removed after having been activated
+              # As it's unused by execjscb we are not cleaning it
+              return super(str, filename) if timeoutv.nil?
+              return if timeoutv <= 0.0
+              timeoutv *= 1000 # Timeout are currently expressed in seconds
+              @timeout = timeoutv
+              @eval_thread = Thread.current
+              timeout do
+                super(str, filename)
+              end
+            end
+
+            def possibly_gc
+              @gc_threshold_in_bytes ||= DEFAULT_GC_THRESHOLD
+              @gc_load ||= 0
+
+              # garbage collections max 1 in every 4 calls (avg)
+              if heap_stats[:total_heap_size] > @gc_threshold_in_bytes
+                low_memory_notification
+                @gc_load += 4
+              else
+                @gc_load = [0, @gc_load - 1].max
+              end
+            end
+
+            private
+
+            def transf_global_funcs(code_id)
+              # Multiple callbacks may share the same name. In order to avoid collisions, we rename them here.
+              eval_unsafe <<-JS
+                Object.keys(this).forEach(name => {
+                  if (typeof this[name] === "function" && !name.startsWith("sqreen_")) {
+                    this['sqreen_#{code_id}_' + name] = this[name];
+                    this[name] = undefined;
+                  }
+                });
+              JS
+            end
+          end
+        end
+      end
+    end
+  end
+end

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