stackify-api-ruby 1.0.15 → 1.2.9

data/lib/stackify/authorization/authorization_client.rb

@@ -14,16 +14,20 @@ module Stackify::Authorizable
     end
 
     def auth_task attempts
-      properties = {
-        limit: 1,
-        attempts: attempts,
-        success_condition: lambda do |result|
-          result.try(:status) == 200
+      begin
+        properties = {
+          limit: 1,
+          attempts: attempts,
+          success_condition: lambda do |result|
+            result.try(:status) == 200
+          end
+        }
+        Stackify::ScheduleTask.new properties do
+          Stackify.internal_log :debug, '[AuthorizationClient] trying to authorize...'
+          send_request BASE_URI, Stackify::EnvDetails.instance.auth_info.to_json
         end
-      }
-      Stackify::ScheduleTask.new properties do
-        Stackify.internal_log :debug, '[AuthorizationClient] trying to authorize...'
-        send_request BASE_URI, Stackify::EnvDetails.instance.auth_info.to_json
+      rescue => exception
+        Stackify.log_internal_error "[AuthorizationClient]: An error occured in auth_task!"
       end
     end
   end

data/lib/stackify/engine.rb

@@ -4,7 +4,32 @@ module Stackify
 
     if Rails.version > '3.1'
       initializer 'Stackify set up of logger', group: :all do
+        if Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new('4.0')
+          # check if the client app is using the ActiveSupport::Logger
+          is_activesupport_logger = ::Rails.logger.is_a?(ActiveSupport::Logger)
+        elsif Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new('3.0')
+          Stackify::Utils.check_buffered_logger
+        end
+
+        # Check if the log output is STDOUT
+        Stackify::Utils.check_log_output
+
+        # Proxy the client Rails logger and write logs to its default log_path.
+        # At the same time, we send the log messages to the LoggerClient.
         ::Rails.logger = ::Stackify::LoggerProxy.new ::Rails.logger
+
+        if Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new('6.0')
+          set_console_logs ::Rails.logger
+        elsif Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new('4.0')
+          if is_activesupport_logger && Stackify.configuration.stdout_output
+            set_console_logs ::Rails.logger
+          end
+          # Another checking if the client app is using the default logger and not STDOUT
+          if Stackify.configuration.stdout_output == false
+            set_console_logs ::Rails.logger
+          end
+        end
+
         Stackify.run
       end
 
@@ -14,6 +39,16 @@ module Stackify
         end
       end
 
+      def set_console_logs logger
+        # Handle the stdout logs from Action Controller
+        ActionController::Base.logger = logger
+
+        # Handle the stdout logs from Action View
+        ActionView::Base.logger = logger
+
+        # Handle the stdout logs from Active Record
+        ActiveRecord::Base.logger = logger
+      end
     end
 
   end

data/lib/stackify/error.rb

@@ -31,12 +31,16 @@ module Stackify
     end
 
     def error_type
-      @exception.class
+      if @exception.class.to_s == 'StringException'
+        @exception.message.split(" ")[0].to_s
+      else
+        @exception.class
+      end
     end
 
     def to_h
       env = Stackify::EnvDetails.instance
-      {
+      data = {
         'OccurredEpochMillis' => Time.now.to_f*1000,
         'Error' => {
           'InnerError' => @exception.try(:cause),
@@ -48,11 +52,20 @@ module Stackify
           'SourceMethod' => source_method,
         },
         'EnvironmentDetail' => env.auth_info,
-        'WebRequestDetail' => env.request_details.try{ |d| d.fetch('webrequest_details', '') },
-        'ServerVariables' => env.request_details.try{ |d| d.fetch('server_variables', '') },
         'CustomerName' => 'Customer',
         'UserName' => @context.fetch('user', '')
       }
+      web_request_details = env.request_details.try{ |d| d.fetch('webrequest_details', '') }
+      if web_request_details.nil?
+        data['WebRequestDetail'] = web_request_details
+      end
+
+      server_variables = env.request_details.try{ |d| d.fetch('server_variables', '') }
+      if server_variables.nil?
+        data['ServerVariables'] = server_variables
+      end
+
+      data
     end
 
   end

data/lib/stackify/http_client.rb

@@ -25,6 +25,7 @@ module Stackify
                       req.headers = headers
                       req.body = body
                     end
+      return @response
       rescue => ex
         @errors << ex
         Stackify.log_internal_error('HttpClient: ' + ex.message+ ' Backtrace: '+ Stackify::Backtrace.backtrace_in_line(ex.backtrace))

data/lib/stackify/logger_client.rb

@@ -2,36 +2,57 @@ module Stackify
   class LoggerClient
 
     def initialize
-      @@errors_governor = Stackify::ErrorsGovernor.new
-    end
-
-    def log level, msg, call_trace
-      Stackify::Utils.do_only_if_authorized_and_mode_is_on Stackify::MODES[:logging] do
-        if acceptable?(level, msg) && Stackify.working?
-          worker = Stackify::AddMsgWorker.new
-          task = log_message_task level, msg, call_trace
-          worker.async_perform ScheduleDelay.new, task
-        end
+      begin
+        @@errors_governor = Stackify::ErrorsGovernor.new
+        @@transport = Stackify::TransportSelector.new(Stackify.configuration.transport).transport
+        Stackify.internal_log :info, "[LoggerClient] initialize: #{@@transport}"
+        return if @@transport.nil?
+      rescue => ex
+        Stackify.log_internal_error "[LoggerClient] initialize exception = #{ex.inspect}"
       end
     end
 
-    def log_exception level= :error, ex
-      if ex.is_a?(Stackify::StackifiedError)
-        Stackify::Utils.do_only_if_authorized_and_mode_is_on Stackify::MODES[:logging] do
-          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 ScheduleDelay.new, task
-            else
-              Stackify.internal_log :warn,
-              "LoggerClient: logging of exception with message \"#{ex.message}\" is skipped - flood_limit is exceeded"
+    # This function is responsible in displaying log messages based on the level criteria
+    # @param num_level [Integer]  level of the clients Rails.logger
+    # @param level [String]       level coming from array of levels(debug info warn error fatal unknown) that we are going to filter with num_level
+    #                             So we filter all logs from num_level up to this level
+    # @param msg [Integer]        log messages
+    # @param call_trace [Object]  return the current execution stack
+    def log num_level, level, msg, call_trace
+      display_log = true
+      log_appender = false
+      buffer_log = false
+      if defined? Rails
+        display_log = false if Stackify.configuration.stdout_output
+        log_appender = true if defined?(Logging)
+        buffer_log = true if Stackify.configuration.buffered_logger
+        unless buffer_log
+          if Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new('4.0')
+            if display_log && log_appender
+              puts msg if num_level <= Logger.const_get(level.upcase).to_i
+            elsif display_log && log_appender == false
+              puts msg if num_level <= Logger.const_get(level.upcase).to_i
             end
           end
         end
       else
-        Stackify.log_internal_error 'LoggerClient: log_exception should get StackifiedError object'
+        puts msg if num_level <= Logger.const_get(level.upcase).to_i
       end
+
+      return if @@transport.nil?
+      task = log_message_task level, msg, call_trace
+      @@transport.log level, msg, call_trace, task
+    end
+
+    def log_exception level= :error, ex
+      return if @@transport.nil?
+      task = log_exception_task level, ex
+      @@transport.log_exception level, ex, task
+    end
+
+    def get_transport
+      return if @@transport.nil?
+      @@transport
     end
 
     private
@@ -52,39 +73,13 @@ module Stackify
     end
 
     def log_message_task level, msg, call_trace, trans_id=nil, log_uuid=nil
-      Stackify::ScheduleTask.new ({limit: 1}) do
-        if %w(error fatal).include?(level)
-          ex = if ruby_exception?(msg) && msg.class != Class
-            msg.set_backtrace(call_trace)
-            msg
-          else
-            e = StringException.new(msg)
-            e.set_backtrace(call_trace)
-            e
-          end
-          ex = StackifiedError.new(ex, binding())
-          Stackify.msgs_queue << Stackify::MsgObject.new(level, ex.message, caller[0], trans_id, log_uuid, ex).to_h
-        else
-          Stackify.msgs_queue << Stackify::MsgObject.new(level, msg, caller[0], trans_id, log_uuid).to_h
-        end
-      end
+      return if @@transport.nil?
+      @@transport.log_message_task level, msg, call_trace, trans_id, log_uuid
     end
 
     def log_exception_task level, ex, trans_id=nil, log_uuid=nil
-      Stackify::ScheduleTask.new ({limit: 1}) do
-        Stackify.msgs_queue << Stackify::MsgObject.new(level, ex.message, caller[0], trans_id, log_uuid, ex).to_h
-      end
-    end
-
-    def ruby_exception? klass
-      klass = klass.class == Class ? klass : klass.class
-      klasses = [klass]
-      while klass != Object do
-        klasses << klass.superclass
-        klass = klass.superclass
-      end
-      klasses.include?(Exception)
+      return if @@transport.nil?
+      @@transport.log_exception_task level, ex, trans_id, log_uuid
     end
   end
-
 end

data/lib/stackify/logger_proxy.rb

@@ -1,14 +1,16 @@
+
 module Stackify
   class LoggerProxy < Object
 
     def initialize logger
-      @logger = logger
-      @logger.level = Logger.const_get(Stackify.configuration.log_level.to_s.upcase)
+      rails_logger  = logger
+      num_level     = logger.level
+      @logger       = rails_logger
       %w(debug info warn error fatal unknown).each do |level|
         stackify_logger = if level == 'debug'
-          -> (msg, caller) { Stackify.logger_client.log(level.downcase, msg, caller) unless msg.to_s.empty? }
+          -> (msg, caller) { Stackify.logger_client.log(num_level, level.downcase, msg, caller) unless msg.to_s.empty? }
         else
-          -> (msg, caller) { Stackify.logger_client.log(level.downcase, msg, caller) }
+          -> (msg, caller) { Stackify.logger_client.log(num_level, level.downcase, msg, caller) }
         end
         LoggerProxy.class_eval do
           define_method level.to_sym do |*args , &block|

data/lib/stackify/logs_sender.rb

@@ -3,13 +3,102 @@ module Stackify
 
     LOGS_URI = URI("#{Stackify.configuration.base_api_url}/Log/Save")
 
+    def initialize
+      @@errors_governor = Stackify::ErrorsGovernor.new
+    end
+
+    def log level, msg, call_trace, task
+      Stackify::Utils.do_only_if_authorized_and_mode_is_on Stackify::MODES[:logging] do
+        if acceptable?(level, msg) && Stackify.working?
+          worker = Stackify::AddMsgWorker.new
+          worker.async_perform ScheduleDelay.new, task
+        end
+      end
+    end
+
+    def log_exception level= :error, ex, task
+      if ex.is_a?(Stackify::StackifiedError)
+        Stackify::Utils.do_only_if_authorized_and_mode_is_on Stackify::MODES[:logging] do
+          if acceptable?(level, ex.message) && Stackify.working?
+            if @@errors_governor.can_send? ex
+              worker = Stackify::AddMsgWorker.new
+              worker.async_perform ScheduleDelay.new, task
+            else
+              Stackify.internal_log :warn,
+              "LoggerClient: logging of exception with message \"#{ex.message}\" is skipped - flood_limit is exceeded"
+            end
+          end
+        end
+      else
+        Stackify.log_internal_error 'LoggerClient: log_exception should get StackifiedError object'
+      end
+    end
+
+    def has_error msg
+      !msg['Ex'].nil?
+    end
+
+    def get_epoch msg
+      msg['EpochMs']
+    end
+
+    def log_message_task level, msg, call_trace, trans_id=nil, log_uuid=nil
+      Stackify::ScheduleTask.new ({limit: 1}) do
+        if %w(error fatal).include?(level)
+          ex = if ruby_exception?(msg) && msg.class != Class
+            msg.set_backtrace(call_trace)
+            msg
+          else
+            e = StringException.new(msg)
+            e.set_backtrace(call_trace)
+            e
+          end
+          ex = StackifiedError.new(ex, binding())
+          Stackify.msgs_queue << Stackify::MsgObject.new(level, ex.message, caller[0], trans_id, log_uuid, ex).to_h
+        else
+          Stackify.msgs_queue << Stackify::MsgObject.new(level, msg, caller[0], trans_id, log_uuid).to_h
+        end
+      end
+    end
+
+    def log_exception_task level, ex, trans_id=nil, log_uuid=nil
+      Stackify::ScheduleTask.new ({limit: 1}) do
+        Stackify.msgs_queue << Stackify::MsgObject.new(level, ex.message, caller[0], trans_id, log_uuid, ex).to_h
+      end
+    end
+
     def send_logs msgs, attempts = 3
       worker = Stackify::LogsSenderWorker.new
       task = send_logs_task attempts, msgs
       worker.async_perform ScheduleDelay.new, task
     end
 
-  private
+    private
+
+    def acceptable? level, msg
+      Stackify.is_valid? && is_correct_log_level?(level) &&
+        is_not_internal_log_message?(msg)
+    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 ruby_exception? klass
+      klass = klass.class == Class ? klass : klass.class
+      klasses = [klass]
+      while klass != Object do
+        klasses << klass.superclass
+        klass = klass.superclass
+      end
+      klasses.include?(Exception)
+    end
 
     def properties
       {

data/lib/stackify/metrics/metrics_client.rb

@@ -1,6 +1,6 @@
 module Stackify::Metrics
   class MetricsClient
-
+    TEN_MINUTES = 600
     attr_reader :metrics_queue
 
     def initialize
@@ -57,7 +57,7 @@ module Stackify::Metrics
 
     def start_upload_metrics
       current_time = Stackify::Utils.rounded_current_time
-      purge_older_than = current_time - 10.minutes
+      purge_older_than = current_time - TEN_MINUTES
       #read everything up to the start of the current minute
       read_queued_metrics_batch current_time
       handle_zero_reports current_time
@@ -67,7 +67,7 @@ module Stackify::Metrics
       if first_50_metrics.length > 0
         #only getting metrics less than 10 minutes old to drop old data in case we get backed up
         #they are removed from the @aggregated_metrics in the upload function upon success
-        upload_aggregates(first_50_metrics.select { |_key, aggr| aggr.occurred_utc > current_time - 10.minutes })
+        upload_aggregates(first_50_metrics.select { |_key, aggr| aggr.occurred_utc > current_time - TEN_MINUTES })
       end
       @aggregate_metrics.delete_if { |_key, aggr| aggr.occurred_utc < purge_older_than }
     end

data/lib/stackify/msgs_queue.rb

@@ -34,7 +34,7 @@ module Stackify
         Stackify.internal_log :info, '[MsgsQueue] All remained logs are going to be sent'
         Stackify.shutdown_all
         if self.length > 0
-          Stackify.logs_sender.send_logs(pop_all)
+          Stackify.get_transport.send_logs(pop_all)
           Stackify.status = Stackify::STATUSES[:terminated]
         end
       end
@@ -47,7 +47,12 @@ module Stackify
         Stackify.internal_log :debug, "[MsgsQueue] add_msg() Newly created worker <#{@worker.name}>"
       end
       self.synchronize do
-        Stackify::Utils.do_only_if_authorized_and_mode_is_on Stackify::MODES[:logging] do
+        case Stackify.configuration.transport
+        when Stackify::DEFAULT
+          Stackify::Utils.do_only_if_authorized_and_mode_is_on Stackify::MODES[:logging] do
+            old_push(msg)
+          end
+        when Stackify::UNIX_SOCKET, Stackify::AGENT_HTTP
           old_push(msg)
         end
       end
@@ -109,13 +114,13 @@ module Stackify
           if length > 0
             msg = pop
             chunk << msg
-            chunk_weight += (msg['Ex'].nil? ? LOG_SIZE : ERROR_SIZE)
-            break if msg['EpochMs'] > started_at || CHUNK_MIN_WEIGHT > 50
+            chunk_weight += Stackify.get_transport.has_error(msg) ? ERROR_SIZE : LOG_SIZE
+            break if Stackify.get_transport.get_epoch(msg) > started_at || CHUNK_MIN_WEIGHT > 50
           else
             break
           end
         end
-        Stackify.logs_sender.send_logs(chunk) if chunk.length > 0
+        Stackify.get_transport.send_logs(chunk) if chunk.length > 0
         chunk_weight
       end
     end

data/lib/stackify/transport_selector.rb

@@ -0,0 +1,15 @@
+module Stackify
+  class TransportSelector
+
+    attr_reader :transport
+
+    def initialize type
+      case type
+      when Stackify::DEFAULT
+        @transport = Stackify::LogsSender.new
+      when Stackify::UNIX_SOCKET, Stackify::AGENT_HTTP
+        @transport = Stackify::AgentClient.new
+      end
+    end
+  end
+end