stackify-api-ruby 1.0.0

data/lib/stackify/metrics/metrics_queue.rb

@@ -0,0 +1,26 @@
+module Stackify::Metrics
+  class MetricsQueue < SizedQueue
+    include MonitorMixin
+
+    def initialize
+      super(Stackify.configuration.queue_max_size)
+    end
+
+    alias :old_push :push
+
+    def add_metric metric
+      self.synchronize do 
+        self.old_push metric
+      end
+    end
+
+    alias :old_size :size 
+
+    def size 
+      self.synchronize do 
+        self.old_size
+      end
+    end
+    
+  end
+end

data/lib/stackify/metrics/metrics_sender.rb

@@ -0,0 +1,32 @@
+module Stackify::Metrics
+  class MetricsSender < Stackify::HttpClient
+    SUBMIT_METRIS_URI = URI('https://dev.stackify.com/api/Metrics/SubmitMetricsByID')
+    GET_METRIC_INFO_URI = URI('https://dev.stackify.com/api/Metrics/GetMetricInfo')
+
+    def initialize
+    end
+
+    def monitor_info aggr_metric
+      if Stackify.authorized?
+        send_request GET_METRIC_INFO_URI, GetMetricRequest.new(aggr_metric).to_h.to_json
+      else
+        Stackify.log_internal_error "Getting of monitor_info is failed because of authorisation failure"
+      end
+    end
+
+    def upload_metrics aggr_metrics
+      return true if aggr_metrics.nil? || aggr_metrics.length == 0
+      if Stackify.authorized?
+        records = []
+        aggr_metrics.each_pair do |_key, metric|
+          records << Stackify::Metrics::MetricForSubmit.new(metric).to_h
+          prms = [metric.category, metric.name, metric.count, metric.value, metric.monitor_id ]
+          Stackify.internal_log :debug, 'Uploading metric: %s: %s count %s, value %s, ID %s' %  prms
+        end
+        send_request SUBMIT_METRIS_URI, records.to_json
+      else
+        Stackify.log_internal_error "Uploading of metrics is failed because of authorisation failure"
+      end
+    end
+  end
+end

data/lib/stackify/metrics/monitor.rb

@@ -0,0 +1,34 @@
+module Stackify::Metrics
+  class GetMetricRequest
+    attr_accessor :category, :metric_name, :device_id,
+                  :device_app_id, :app_name_id, :metric_type_id
+
+    def initialize aggr_metric
+      @metric_name = aggr_metric.name
+      @metric_type_id = aggr_metric.metric_type
+      @category = aggr_metric.category
+      @device_app_id = Stackify::EnvDetails.instance.auth_info['DeviceAppID']
+      @device_id = Stackify::EnvDetails.instance.auth_info['DeviceID']
+      @app_name_id = Stackify::EnvDetails.instance.auth_info['AppNameID']
+    end
+
+    def to_h
+      {
+        'DeviceAppID' => @device_app_id,
+        'DeviceID' => @device_id,
+        'AppNameID' => @app_name_id,
+        'MetricName' => @metric_name,
+        'MetricTypeID' => @metric_type_id,
+        'Category' => @category
+      }
+    end
+  end
+
+  class GetMetricResponse
+    attr_accessor :monitor_id
+    def initialize
+    end
+  end
+
+
+end

data/lib/stackify/msgs_queue.rb

@@ -0,0 +1,78 @@
+module Stackify
+  class MsgsQueue < SizedQueue
+    include MonitorMixin
+    #TODO: restrict possibility to work with class if app is off
+    CHUNK_MIN_WEIGHT = 50
+    ERROR_SIZE = 10
+    LOG_SIZE = 1
+    DELAY_WAITING = 2
+
+    def initialize
+      super(Stackify.configuration.queue_max_size)
+      reset_current_chunk
+    end
+
+    alias :old_push :push
+
+    def push_remained_msgs
+      wait_until_all_workers_will_add_msgs
+      self.synchronize do
+        push_current_chunk
+        Stackify.shutdown_all
+        if self.length > 0
+          Stackify.logs_sender.send_remained_msgs
+          Stackify.internal_log :info, 'All remained logs are sent'
+          Stackify.status = Stackify::STATUSES[:terminated]
+        end
+      end
+    end
+
+    def add_msg msg
+      self.synchronize do
+        if msg.is_a?(Hash)
+          @current_chunk_weight += msg['Ex'].nil? ? LOG_SIZE : ERROR_SIZE
+          @current_chunk << msg
+          if @current_chunk_weight >= CHUNK_MIN_WEIGHT
+            self.old_push(@current_chunk)
+            reset_current_chunk
+          end
+        else
+          Stackify.log_internal_error "MsgsQueue: add_msg should get hash, but not a #{msg.class}"
+        end
+      end
+    end
+
+    alias :<< :add_msg
+    alias :push :add_msg
+
+    def pop_all
+      self.synchronize do
+        msgs = []
+        until self.empty? do
+          msgs << self.pop
+        end
+        msgs
+      end
+    end
+
+    private
+
+    def reset_current_chunk
+      @current_chunk = []
+      @current_chunk_weight = 0
+    end
+
+    def wait_until_all_workers_will_add_msgs
+      while Stackify.alive_adding_msg_workers.size > 0
+        sleep DELAY_WAITING
+      end
+    end
+
+    def push_current_chunk
+      unless @current_chunk.empty?
+        self.old_push(@current_chunk)
+        reset_current_chunk
+      end
+    end
+  end
+end

data/lib/stackify/rack/errors_catcher.rb

@@ -0,0 +1,17 @@
+module Stackify
+  class ErrorsCatcher
+    def initialize(app, &block)
+      @app = app
+      @block = block
+    end
+
+    def call(env)
+      @block.call env
+      @app.call env
+    rescue Exception => exception
+      Stackify.logger_client.log_exception(StackifiedError.new exception, binding)
+      raise exception
+    end
+
+  end
+end

data/lib/stackify/schedule_task.rb

@@ -0,0 +1,23 @@
+module Stackify
+  class ScheduleTask
+
+    attr_reader :limit, :attempts, :action
+
+    def initialize properties={}, &action
+      @limit = properties[:limit] || nil
+      @attempts = properties[:attempts] || 3
+      @success_condition = properties[:success_condition] || lambda{ |_result| true }
+      @action = action
+    end
+
+    def execute!
+      @action.call
+    end
+
+    def success? result_of_task_execution
+      @success_condition.call result_of_task_execution
+    end
+
+  end
+
+end

data/lib/stackify/scheduler.rb

@@ -0,0 +1,79 @@
+require 'thread'
+module Stackify
+
+  class Scheduler
+
+    attr_accessor :period
+    attr_reader :iterations
+
+    def initialize
+      @should_run = true
+      @next_invocation_time = Time.now
+      @period = 60.0
+      @iterations = 0
+      @attempts = 3
+    end
+
+    def setup(period, task)
+      @task = task
+      @period = period if period
+      @should_run = true
+      @iterations = 0
+      @attempts = @task.attempts if @task.attempts
+      now = Time.now
+      @next_invocation_time = (now + @period)
+    end
+
+    def run(period=nil, task)
+      setup(period, task)
+      while keep_running? do
+        sleep_time = schedule_next_invocation
+        sleep(sleep_time) if sleep_time > 0 && @iterations != 0
+        @task_result = run_task if keep_running?
+        if @task.success? @task_result
+          @iterations += 1
+          @attempts = @task.attempts || @attempts
+        else
+          @attempts -= 1
+        end
+      end
+      @task.success? @task_result
+    end
+
+    def schedule_next_invocation
+      now = Time.now
+      while @next_invocation_time <= now && @period > 0
+        @next_invocation_time += @period
+      end
+      @next_invocation_time - Time.now
+    end
+
+    def keep_running?
+      @should_run && limit_is_not_reached? && attemps_are_not_over?
+    end
+
+    def attemps_are_not_over?
+      @attempts.nil? || @attempts > 0
+    end
+
+    def limit_is_not_reached?
+      @task.limit.nil? || @iterations < @task.limit
+    end
+
+    def stop
+      @should_run = false
+    end
+
+    def task_result
+      @task_result
+    end
+
+    def run_task
+      begin
+        @task.execute!
+      rescue Exception => e
+        ::Stackify.log_internal_error 'Scheduler: ' + e.message + '' + e.backtrace.to_s
+      end
+    end
+  end
+end

data/lib/stackify/utils/backtrace.rb

@@ -0,0 +1,36 @@
+module Stackify::Backtrace
+
+  ALL_TEXT_FROM_START_TO_FIRST_COLON_REGEXP = /\A([^:]+)/
+  NUMBER_BETWEEN_TWO_COLONS_REGEXP = /:(\d+):/
+  TEXT_AFTER_IN_BEFORE_END_REGEXP = /in\s`(\S+)'\z/
+
+  def self.line_number backtrace_str
+    backtrace_str[NUMBER_BETWEEN_TWO_COLONS_REGEXP, 1]
+  end
+
+  def self.method_name backtrace_str
+    return nil unless backtrace_str
+    backtrace_str[TEXT_AFTER_IN_BEFORE_END_REGEXP, 1]
+  end
+
+  def self.file_name backtrace_str
+    backtrace_str[ALL_TEXT_FROM_START_TO_FIRST_COLON_REGEXP, 1]
+  end
+
+  def self.stacktrace depth=5, backtrace
+    return nil unless backtrace
+    new_backtrace = []
+    backtrace.take(depth).each do |line|
+      new_backtrace << {
+        'LineNum' => line_number(line),
+        'Method' => method_name(line),
+        'CodeFileName' => file_name(line)
+      }
+    end
+    new_backtrace
+  end
+
+  def self.backtrace_in_line backtrace
+    backtrace.join("\n")
+  end
+end

data/lib/stackify/utils/configuration.rb

@@ -0,0 +1,78 @@
+module Stackify
+
+  class Configuration
+
+    attr_accessor :api_key, :app_name, :app_location, :env, :log_level, :flood_limit,
+                  :queue_max_size, :logger, :send_interval, :with_proxy,
+                  :proxy_host, :proxy_port, :proxy_user, :proxy_pass, :mode
+
+    attr_reader :errors
+
+    def initialize
+      @errors = []
+      @api_key = ''
+      @env = :production
+      @flood_limit = 100
+      @queue_max_size = 1000
+      @send_interval = 60
+      @with_proxy = false
+      @log_level = :info
+      @mode = MODES[:both]
+      @logger = if defined? Rails
+        Logger.new(File.join(Rails.root, 'log', 'stackify.log'))
+      else
+        Logger.new('stackify.log')
+      end
+    end
+
+    def is_valid?
+      @errors = []
+      validate_send_interval && validate_mode if validate_config_types
+      @errors.empty?
+    end
+
+    private
+    def validate_send_interval
+      return true if 60 <= @send_interval && @send_interval <= 60000
+      @errors << 'Send interval is not correct!'
+    end
+
+    def validate_config_types
+      validate_api_key &&
+      validate_flood_limit_queue_max_size_and_send_interval &&
+      validate_log_level &&
+      validate_mode_type
+    end
+
+    def validate_mode_type
+      return true if @mode.is_a? Symbol
+      @errors << 'Mode should be a Symbol'
+    end
+
+    def validate_api_key
+      return true if  @api_key.is_a? String
+      @errors << 'API_KEY should be a String'
+    end
+
+    def validate_flood_limit_queue_max_size_and_send_interval
+      answer = true
+      { 'Flood limit' => @flood_limit, "Queue's max size" => @queue_max_size, 'Send interval' => @send_interval }.each_pair do |k, v|
+        unless v.is_a? Integer
+          answer = false
+          @errors << "#{k} should be an Integer"
+        end
+      end
+      answer
+    end
+
+    def validate_log_level
+      return true if  [:debug, :warn, :info, :error, :fatal].include? @log_level
+      @errors << "Log's level should has one of these values: [:debug, :warn, :info, :error, :fatal]"
+    end
+
+    def validate_mode
+      return true if MODES.has_value? @mode
+      @errors << 'Mode should be one of these values: [:both, :logging, :metrics]'
+    end
+  end
+end

data/lib/stackify/utils/methods.rb

@@ -0,0 +1,27 @@
+module Stackify::Utils
+
+  def self.current_minute
+    Time.now.utc.to_i/60
+  end
+
+  def self.rounded_current_time
+    t = Time.now.utc
+    t - t.sec
+  end
+
+  def self.is_mode_on? mode
+    Stackify.configuration.mode == Stackify::MODES[:both] || Stackify.configuration.mode == mode
+  end
+
+  def self.do_only_if_authorized_and_mode_is_on mode, &block
+    if Stackify.authorized?
+      if is_mode_on? mode
+        yield
+      else
+        Stackify.internal_log :warn, "#{caller[0]}: Skipped because mode - #{mode.to_s} is disabled at configuration"
+      end
+    else
+      Stackify.internal_log :warn, "#{caller[0]}: Skipped due to authorization failure"
+    end
+  end
+end