sqreen 0.7.01461158029-java

data/lib/sqreen/log.rb

@@ -0,0 +1,116 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+require 'logger'
+
+require 'sqreen/performance_notifications/log'
+require 'sqreen/configuration'
+
+module Sqreen
+  def self::log
+    return @logger unless @logger.nil?
+    @logger = Logger.new(
+      Sqreen.config_get(:log_level),
+      Sqreen.config_get(:log_location)
+    )
+  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
+    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
+
+    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'
+    end
+
+    def create_error_logger
+      @error_logger = ::Logger.new(STDERR)
+      enforce_log_format(@error_logger)
+    end
+
+    def enforce_log_format(logger)
+      logger.formatter = FormatterWithTid.new
+    end
+  end
+end

data/lib/sqreen/metrics.rb

@@ -0,0 +1,6 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+require 'sqreen/metrics/collect'
+require 'sqreen/metrics/average'
+require 'sqreen/metrics/sum'

data/lib/sqreen/metrics/average.rb

@@ -0,0 +1,39 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+require 'sqreen/metrics/base'
+
+module Sqreen
+  module Metric
+    # This perform an average aggregation
+    class Average < Base
+      # from class attr_accessor :aggregate
+
+      def update(_at, key, value)
+        super
+        @sums[key] ||= 0
+        @sums[key] += value
+        @counts[key] ||= 0
+        @counts[key] += 1
+      end
+
+      protected
+
+      def new_sample(time)
+        super(time)
+        @sums = {}
+        @counts = {}
+      end
+
+      def finalize_sample(time)
+        super(time)
+        @sample[FINISH_KEY] = time
+        h = {}
+        @sums.each do |k, v|
+          h[k] = v.to_f / @counts[k]
+        end
+        @sample[OBSERVATION_KEY] = h
+      end
+    end
+  end
+end

data/lib/sqreen/metrics/base.rb

@@ -0,0 +1,41 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+require 'sqreen/exception'
+
+module Sqreen
+  module Metric
+    OBSERVATION_KEY = 'observation'.freeze
+    START_KEY = 'start'.freeze
+    FINISH_KEY = 'finish'.freeze
+    # Base interface for a metric
+    class Base
+      # Update the current metric with a new observation
+      # @param _at [Time] when was the observation made
+      # @param _key [String] which aggregation key was it made for
+      # @param _value [Object] The observation
+      def update(_at, _key, _value)
+        raise Sqreen::Exception, 'No current sample' unless @sample
+      end
+
+      # create a new empty sample and publish the last one
+      # @param time [Time] Time of start/finish
+      def next_sample(time)
+        finalize_sample(time) unless @sample.nil?
+        current_sample = @sample
+        new_sample(time)
+        current_sample
+      end
+
+      protected
+
+      def new_sample(time)
+        @sample = { OBSERVATION_KEY => {}, START_KEY => time }
+      end
+
+      def finalize_sample(time)
+        @sample[FINISH_KEY] = time
+      end
+    end
+  end
+end

data/lib/sqreen/metrics/collect.rb

@@ -0,0 +1,22 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+require 'sqreen/metrics/base'
+
+module Sqreen
+  module Metric
+    # This is an aggregated statistic definition
+    # This is a base class to collect metrics in a hash based structure
+    # that does not aggregate anything
+    class Collect < Base
+      # from class attr_accessor :aggregate
+
+      def update(_at, key, value)
+        super
+        s = @sample[OBSERVATION_KEY]
+        s[key] ||= []
+        s[key] << value
+      end
+    end
+  end
+end

data/lib/sqreen/metrics/sum.rb

@@ -0,0 +1,20 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+require 'sqreen/metrics/base'
+
+module Sqreen
+  module Metric
+    # This perform a sum aggregation
+    class Sum < Base
+      # from class attr_accessor :aggregate
+
+      def update(_at, key, value)
+        super
+        s = @sample[OBSERVATION_KEY]
+        s[key] ||= 0
+        s[key] += value
+      end
+    end
+  end
+end

data/lib/sqreen/metrics_store.rb

@@ -0,0 +1,94 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+require 'sqreen/exception'
+require 'sqreen/metrics'
+
+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
+
+    NAME_KEY = 'name'.freeze
+    KIND_KEY = 'kind'.freeze
+    PERIOD_KEY = 'period'.freeze
+
+    # Currently ready samples
+    attr_reader :store
+
+    def initialize
+      @store = []
+      @metrics = {}
+    end
+
+    # Definition contains a name,period and aggregate at least
+    # @param definition [Hash] a metric definition
+    # @param klass [Object] Override metric class (used in testing)
+    def create_metric(definition, mklass = nil)
+      name = definition[NAME_KEY]
+      kind = definition[KIND_KEY]
+      klass = valid_metric(kind, name)
+      metric = mklass || klass.new
+      @metrics[name] = [
+        metric,
+        definition[PERIOD_KEY],
+        nil # Start
+      ]
+      metric
+    end
+
+    def update(name, at, key, value)
+      at = at.utc
+      metric, period, start = @metrics[name]
+      raise UnregisteredMetric, "Unknown metric #{name}" unless metric
+      next_sample(name, at) if start.nil? || start + period < at
+      metric.update(at, key, value)
+    end
+
+    # Drains every metrics and returns the store content
+    # @params at [Time] when is the store emptied
+    def publish(at = Time.now.utc)
+      @metrics.each_key do |name|
+        next_sample(name, at)
+      end
+      out = @store
+      @store = []
+      out
+    end
+
+    protected
+
+    def next_sample(name, at)
+      metric = @metrics[name][0]
+      r = metric.next_sample(at)
+      @metrics[name][2] = at
+      if r
+        r[NAME_KEY] = name
+        obs = r[Metric::OBSERVATION_KEY]
+        @store << r if obs && (!obs.respond_to?(:empty?) || !obs.empty?)
+      end
+      r
+    end
+
+    def valid_metric(kind, name)
+      unless Sqreen::Metric.const_defined?(kind)
+        raise UnknownMetric, "No such #{kind} metric"
+      end
+      klass = Sqreen::Metric.const_get(kind)
+      metric = @metrics[name] && @metrics[name][0]
+      if metric && metric.class != klass
+        msg = "Was a #{metric.class.name} not a #{klass.name} "
+        raise AlreadyRegisteredMetric, msg
+      end
+      klass
+    end
+  end
+end

data/lib/sqreen/parsers/sql.rb

@@ -0,0 +1,98 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+require 'sqreen/parsers/sql_tokenizer'
+require 'sqreen/exception'
+
+module Sqreen
+  module Parsers
+    # SELECT * FROM contacts WHERE name = #{name}
+    # name = 'a' 'b'
+
+    class SQLAtom
+      attr_reader :val, :type, :delim
+      def initialize(val, typ = :unkown, delim = nil, token_type = nil)
+        @val = val
+        @type = typ
+        @token_type = token_type
+        @delim = delim
+      end
+
+      def ==(other)
+        return false if other.nil?
+        @val == other.val &&
+          @type == other.type &&
+          @delim == other.delim
+      end
+
+      def is_literal?
+        [:literal_string, :literal_number].include? @type
+      end
+
+      def to_s
+        res = ":#{@type || @token_type}: #{@val}"
+        res += " (#{@delim})" if delim
+        res
+      end
+    end
+
+    class SQL
+      attr_reader :atoms, :tokenizer
+
+      def initialize(db_type, db_infos)
+        klass = case db_type
+                when :mysql
+                  MySQLTokenizer
+                when :sqlite
+                  SQLiteTokenizer
+                else
+                  Sqreen.log.warn format('warning: db_type %s not found, falling back to default SQL type', db_type)
+                  SQLTokenizer
+                end
+        @tokenizer = klass.new(db_type, db_infos)
+      end
+
+      def to_s
+        res = "Parsed: #{@req}\n"
+        nb = 0
+        @atoms.each do |atom|
+          res << "\t" + nb.to_s + ': ' + atom.to_s + "\n"
+          nb += 1
+        end
+        res
+      end
+
+      def parse(req)
+        @req = req
+        @atoms = []
+        @tokenizer.tokenize(req)
+        @tokenizer.each_token do |token, meta_type|
+          value = token[1]
+          type = token[0]
+          delim = case type
+                  when :SINGLE_QUOTED_STRING
+                    "'"
+                  when :DOUBLE_QUOTED_STRING
+                    '"'
+                  end
+          atom = SQLAtom.new(value, meta_type, delim, type)
+          @atoms << atom
+        end
+      end
+
+      def to_atoms(ary, type = :unknown)
+        ary.map { |frag| to_atom(frag, nil, type) }
+      end
+
+      def to_atom(_frag, _type = :unknown, _delim = nil)
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  s = Sqreen::Parsers::SQL.new :mysql, {}
+  s.parse(ARGV[0])
+  puts s
+
+end