stackify-api-ruby 1.0.0

data/lib/stackify/authorization/authorization_client.rb

@@ -0,0 +1,31 @@
+module Stackify::Authorizable
+
+  class AuthorizationClient < Stackify::HttpClient
+
+    BASE_URI = URI('https://dev.stackify.com/api/Metrics/IdentifyApp')
+
+    def initialize
+      super
+      @worker = Stackify::AuthWorker.new
+    end
+
+    def auth attempts, delay_time= 20
+      task = auth_task attempts
+      @worker.perform delay_time, task
+    end
+
+    def auth_task attempts
+      properties = {
+        limit: 1,
+        attempts: attempts,
+        success_condition: lambda do |result|
+          result.try(:code) == '200'
+        end
+      }
+      Stackify::ScheduleTask.new properties do
+        Stackify.internal_log :debug, 'AthorizationClient: trying to athorize...'
+        send_request BASE_URI, Stackify::EnvDetails.instance.auth_info.to_json
+      end
+    end
+  end
+end

data/lib/stackify/engine.rb

@@ -0,0 +1,21 @@
+require 'stackify/rack/errors_catcher'
+module Stackify
+  class Engine < ::Rails::Engine
+
+    if Rails.version > '3.1'
+
+      initializer 'Stackify set up of logger', group: :all do
+        ::Rails.logger = ::Stackify::LoggerProxy.new ::Rails.logger
+        Stackify.run
+      end
+
+      initializer 'stackify.middleware', group: :all do |app|
+        app.config.app_middleware.use 'Stackify::ErrorsCatcher' do |env|
+          Stackify::EnvDetails.instance.request_details = env
+        end
+      end
+
+    end
+
+  end
+end

data/lib/stackify/env_details.rb

@@ -0,0 +1,108 @@
+require 'socket'
+require 'singleton'
+module Stackify
+
+  class EnvDetails
+    include Singleton
+    attr_reader :request_details
+
+    def initialize
+      rails_info = defined?(Rails) ? Rails::Info.properties.to_h : nil
+      @info =  rails_info || { 'Application root' => Dir.pwd, 'Environment' => 'development'}
+      @request_details = nil
+      @app_name = app_name
+      app_location = Stackify.configuration.app_location || @info['Application root']
+      @details = {
+        'DeviceName' => Socket.gethostname,
+        'AppLocation' => app_location,
+        'AppName' => @app_name, 
+        'ConfiguredAppName' => @app_name,
+        'ConfiguredEnvironmentName' =>@info['Environment']
+      }
+    end
+
+    def auth_info
+      with_synchronize{ @details }
+    end
+
+    def update_auth_info info
+      with_synchronize{ @details.merge! info }
+    end
+
+    def request_details= env
+      request = request_instance env
+      @request_details = {
+        'webrequest_details' => {
+          'Headers' => headers(env),
+          'Cookies' => cookies(env),
+          'QueryString' => request.try(:GET),
+          'PostData' => request.try(:POST),
+          'PostDataRaw' => request.try(:raw_post),
+          'SessionData' => request.try(:session),
+          'UserIPAddress' => request.try(:remote_ip) || request.try(:ip),
+          'HttpMethod' => request.try(:request_method),
+          'ReferralUrl' => request.referer,
+          'RequestUrl' => request.try(:fullpath),
+          'RequestUrlRoot' => request.try(:base_url),
+          'RequestProtocol' => request.try(:scheme)
+        },
+        'server_variables' => server_variables(env),
+        'uuid' => request.uuid
+      }
+    rescue => e
+      warning = 'failed to capture request parameters: %p: %s' % [ e.class, e.message ]
+      Stackify.logger.warn warning
+    end
+
+    private
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+
+    def with_synchronize
+      mutex.synchronize{ yield }
+    end
+
+    def app_name
+      Stackify.configuration.app_name || Rails.application.config.session_options[:key].sub(/^_/,'').sub(/_session/,'') || 'Unknown'
+    end
+
+    def app_location
+      Stackify.configuration.app_location
+    end
+
+    def cookies env
+      env['action_dispatch.cookies'].to_h
+    end
+
+    def headers env
+      env.reject{ |k| !(k.start_with?'HTTP_') }
+    end
+
+    def server_variables env
+      {
+        'server' => server_name(env['SERVER_SOFTWARE']),
+        'version' => server_version(env['SERVER_SOFTWARE'])
+      }
+    end
+
+    def server_name str
+      str[/(^\S*)\//, 1]
+    end
+
+    def server_version str
+      str[/\/(\S*)\s/, 1]
+    end
+
+    def request_instance env
+      if defined? ActionDispatch::Request
+        ActionDispatch::Request.new env
+      else
+        Rack::Request.new env
+      end
+    end
+
+  end
+
+end

data/lib/stackify/error.rb

@@ -0,0 +1,56 @@
+module Stackify
+
+  class StackifiedError < StandardError
+
+    CONTEXT_PROPERTIES =  { 'user' => 'current_user'}
+
+    attr_reader :context, :exception
+
+    def initialize(ex, error_binding)
+      @exception = ex
+      @context = {}
+      CONTEXT_PROPERTIES.each do |key , value|
+        @context[key] = error_binding.eval(value) if error_binding.local_variable_defined?(value.to_sym)
+      end
+    end
+
+    def backtrace
+      Stackify::Backtrace.stacktrace @exception.backtrace
+    end
+
+    def source_method
+      Stackify::Backtrace.method_name @exception.try{ |e| e.backtrace[0] }
+    end
+
+    def message
+      @exception.message
+    end
+
+    def error_type
+      @exception.class
+    end
+
+    def to_h
+      env = Stackify::EnvDetails.instance
+      {
+        'OccurredEpochMillis' => Time.now.to_f*1000,
+        'Error' => {
+          'InnerError' => @exception.try(:cause),
+          'StackTrace' => backtrace,
+          'Message' => message,
+          'ErrorType' => error_type.to_s,
+          'ErrorTypeCode' => nil,
+          'Data' => { user_id: '1'},
+          'SourceMethod' => source_method,
+        },
+        'EnvironmentDetail' => env.auth_info,
+        'WebRequestDetail' => env.request_details.try{ |d| d['webrequest_details'] },
+        'ServerVariables' => env.request_details.try{ |d| d['server_variables'] },
+        'CustomerName' => 'Customer',
+        'UserName' => @context['user']
+      }
+    end
+
+  end
+
+end

data/lib/stackify/errors_governor.rb

@@ -0,0 +1,65 @@
+module Stackify
+  class ErrorsGovernor
+    require 'digest'
+
+    def initialize purge_period=5
+      @history = {}
+      @@history_lock = Mutex.new
+      @purge_period = purge_period
+      update_purge_times
+    end
+
+    def can_send? ex
+      key = unique_key_of(ex)
+      @@history_lock.synchronize do
+        epoch_minute = current_minute
+        init_history_key_if_not_exists key, epoch_minute
+        history_entry = @history[key]
+        if history_entry[:epoch_minute] == epoch_minute
+          history_entry[:count] += 1
+          answer = (history_entry[:count] <= Stackify.configuration.flood_limit) ? true : false
+        else
+          @history[key]={
+            epoch_minute: epoch_minute,
+            count: 1
+          }
+          answer = true
+        end
+        clear_old_history_entries if time_for_purge_is_come?
+        answer
+      end
+    end
+
+    private
+
+    def unique_key_of ex
+      str = "#{ex.backtrace[0]['LineNum']}-#{ex.source_method}-#{ex.error_type}"
+      Digest::MD5.hexdigest str
+    end
+
+    def init_history_key_if_not_exists key, minute
+      @history[key] ||= {
+        epoch_minute: minute,
+        count: 0
+      }
+    end
+
+    def clear_old_history_entries
+      @history.keep_if{ |_key, entry| entry[:epoch_minute] == current_minute }
+      update_purge_times
+    end
+
+    def update_purge_times
+      @last_purge_minute = current_minute
+      @next_purge_minute = @last_purge_minute + @purge_period
+    end
+
+    def current_minute
+      Time.now.to_i/60
+    end
+
+    def time_for_purge_is_come?
+      !(current_minute < @next_purge_minute)
+    end
+  end
+end

data/lib/stackify/http_client.rb

@@ -0,0 +1,50 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+module Stackify
+  class HttpClient
+
+    HEADERS = {
+      'X-Stackify-PV' => 'V1',
+      'X-Stackify-Key' => Stackify.configuration.api_key,
+      'Content-Type' =>'application/json'
+    }
+    attr_reader :response, :errors
+
+    def initialize
+    end
+
+    private
+
+    def send_request uri, body, headers = HEADERS
+      @errors = []
+      begin
+        https = get_https uri
+        req = Net::HTTP::Post.new uri.path, initheader = headers
+        req.body = body
+        Stackify.internal_log :debug, "============Request body=========================="
+        Stackify.internal_log :debug, req.body
+        Stackify.internal_log :debug, "=================================================="
+        @response = https.request req
+       rescue => ex
+        @errors << ex
+        Stackify.log_internal_error('HttpClient: ' + ex.message+ ' Backtrace: '+ Stackify::Backtrace.backtrace_in_line(ex.backtrace))
+        false
+      end
+    end
+
+    def get_https uri
+      if Stackify.configuration.with_proxy
+        https = Net::HTTP.new uri.host, uri.port,
+                Stackify.configuration.proxy_host,
+                Stackify.configuration.proxy_port,
+                Stackify.configuration.proxy_user,
+                Stackify.configuration.proxy_pass
+      else
+        https = Net::HTTP.new uri.host, uri.port
+      end
+      https.use_ssl = true
+      https
+    end
+  end
+end

data/lib/stackify/logger_client.rb

@@ -0,0 +1,71 @@
+module Stackify
+  class LoggerClient
+    PERIOD = 1
+
+    def initialize
+      @@errors_governor = Stackify::ErrorsGovernor.new
+    end
+
+    def log level, msg
+      if acceptable? level, msg && Stackify.working?
+        worker = Stackify::AddMsgWorker.new
+        task = log_message_task level, msg
+        worker.async_perform PERIOD, task
+      end
+    end
+
+    def log_exception level= :error, ex
+      if ex.is_a?(Stackify::StackifiedError)
+        if acceptable? level, ex.message && Stackify.working?
+          if @@errors_governor.can_send? ex
+            worker = Stackify::AddMsgWorker.new
+            task = log_exception_task level, ex
+            worker.async_perform PERIOD, task
+          else
+            Stackify.internal_log :warn,
+            "LoggerClient: logging of exception with message \"#{ex.message}\" is skipped - flood_limit is exceeded"
+          end
+        end
+      else
+        Stackify.log_internal_error 'LoggerClient: log_exception should get StackifiedError object'
+      end
+    end
+
+    private
+
+    def acceptable? level, msg
+      Stackify.is_valid? && is_correct_log_level?(level) && is_not_internal_log_message?(msg) && is_appropriate_env?
+    end
+
+    def is_not_internal_log_message? msg
+      msg.try(:index, ::Stackify::INTERNAL_LOG_PREFIX).nil?
+    end
+
+    def is_correct_log_level? level
+      config_level = Logger.const_get Stackify.configuration.log_level.to_s.upcase
+      current_level = Logger.const_get level.to_s.upcase
+      current_level >= config_level
+    end
+
+    def is_appropriate_env?
+      Stackify.configuration.env.downcase.to_sym == Stackify::EnvDetails.instance.auth_info['ConfiguredEnvironmentName'].downcase.to_sym
+    end
+
+    def log_message_task level, msg
+      Stackify::ScheduleTask.new ({limit: 1}) do
+        Stackify.msgs_queue.add_msg Stackify::MsgObject.new(level, msg, caller[0]).to_h
+        str = "LoggerClient: logging of message #{msg} with level '#{level}' is completed successfully."
+        Stackify.internal_log :debug, str
+      end
+    end
+
+    def log_exception_task level, ex
+      Stackify::ScheduleTask.new ({limit: 1}) do
+        Stackify.msgs_queue.add_msg Stackify::MsgObject.new(level, ex.message, caller[0], ex).to_h
+        Stackify.internal_log :debug, 'LoggerClient: '+
+        'Logging of the exception %p: %s is completed successfully' % [ ex.class, ex.message ]
+      end
+    end
+  end
+
+end

data/lib/stackify/logger_proxy.rb

@@ -0,0 +1,35 @@
+module Stackify
+  class LoggerProxy < Object
+
+    def initialize logger
+      @logger = logger
+      @logger.level = Logger.const_get(Stackify.configuration.log_level.to_s.upcase)
+      %w( debug info warn error fatal unknown).each do |level|
+        LoggerProxy.class_eval do
+          define_method level.to_sym do |*args , &block|
+            msg = message(args, block)
+            Stackify.logger_client.log(level.downcase, msg)
+            @logger.send(level.to_sym, args, &block)
+          end
+        end
+      end
+    end
+
+    protected
+
+    def method_missing(name, *args, &block)
+      @logger.send(name, *args, &block)
+    end
+
+    private
+
+    def message *args, &block
+      if block
+        block.call
+      else
+        args[0]
+      end
+    end
+
+  end
+end