stackify-api-ruby 1.0.15 → 1.2.9

data/lib/stackify/unix_socket_sender.rb

@@ -0,0 +1,34 @@
+require 'net_http_unix'
+require 'ostruct'
+
+#
+# This class will handle the sending of log messages to unix domain socket
+#
+module Stackify
+  class UnixSocketSender < AgentBaseSender
+
+    # send_request() This function will send http request via unix domain socket
+    # @msgs {Object} log group message
+    # return {Object} Return an object {status, message}
+    def send_request log_group
+      begin
+        client = NetX::HTTPUnix.new('unix://' + Stackify.configuration.unix_socket_path)
+        req = Net::HTTP::Post.new(Stackify.configuration.agent_log_url)
+        req.set_content_type('application/json')
+        req.body = log_group
+        response = client.request(req)
+        Stackify.internal_log :debug, "[UnixSocketSender] status_code = #{response.code}"
+        if response.code.to_i == 200
+          Stackify.internal_log :debug, "[UnixSocketSender]: Successfully send message via unix domain socket."
+          return OpenStruct.new({status: 200, msg: 'OK'})
+        else
+          Stackify.internal_log :debug, "[UnixSocketSender] Sending failed."
+          return OpenStruct.new({status: 500, msg: 'Not OK'})
+        end
+      rescue => exception
+        Stackify.log_internal_error "[UnixSocketSender] send_logs() Error: #{exception}"
+        return OpenStruct.new({status: 500, msg: exception})
+      end
+    end
+  end
+end

data/lib/stackify/utils/backtrace.rb

@@ -3,6 +3,7 @@ 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/
+  TEXT_AFTER_IN_BEFORE_END_REGEXP_ = /in\s(\S+)'\z/
 
   def self.line_number backtrace_str
     backtrace_str[NUMBER_BETWEEN_TWO_COLONS_REGEXP, 1]
@@ -10,7 +11,7 @@ module Stackify::Backtrace
 
   def self.method_name backtrace_str
     return nil unless backtrace_str
-    backtrace_str[TEXT_AFTER_IN_BEFORE_END_REGEXP, 1]
+    backtrace_str[TEXT_AFTER_IN_BEFORE_END_REGEXP, 1] || backtrace_str[TEXT_AFTER_IN_BEFORE_END_REGEXP_, 1]
   end
 
   def self.file_name backtrace_str

data/lib/stackify/utils/configuration.rb

@@ -3,14 +3,16 @@ module Stackify
   class Configuration
 
     attr_accessor :api_key, :app_name, :app_location, :env, :log_level, :logger,
-                  :proxy, :mode, :base_api_url, :api_enabled
+                  :proxy, :mode, :base_api_url, :api_enabled, :transport, :errors, :http_endpoint, :stdout_output, :buffered_logger
 
-    attr_reader :errors, :send_interval, :flood_limit, :queue_max_size
+    attr_reader :send_interval, :flood_limit, :queue_max_size, :agent_log_url, :unix_socket_path, :http_endpoint
 
     def initialize
       @base_api_url = 'https://api.stackify.com'
       @errors = []
+      @app_name = ''
       @api_key = ''
+      @transport = get_env 'STACKIFY_TRANSPORT', 'default'
       @env = :production
       @flood_limit = 100
       @queue_max_size = 10000
@@ -20,14 +22,36 @@ module Stackify
       @mode = MODES[:both]
       @logger = Logger.new(STDOUT)
       @logger.level = Logger::UNKNOWN
+      @agent_log_url = '/log'
+      @unix_socket_path = '/usr/local/stackify/stackify.sock'
+      @http_endpoint = get_env 'STACKIFY_TRANSPORT_HTTP_ENDPOINT', 'https://localhost:10601'
+      @stdout_output = false
+      @buffered_logger = false
+    end
+
+    def get_env env_key, default
+      value = default
+      if ENV.keys.include? env_key
+        value = ENV[env_key]
+      end
+      return value
     end
 
     def is_valid?
-      @errors = []
-      validate_mode if validate_config_types
+      case Stackify.configuration.transport
+      when Stackify::DEFAULT
+        validate_default_transport
+      when Stackify::UNIX_SOCKET, Stackify::AGENT_HTTP
+        validate_agent_transport
+      end
       @errors.empty?
     end
 
+    def validate_transport_type
+      return true if ['agent_socket', 'agent_http', 'default'].include? @transport
+      @errors << 'Transport should be one of these values: [agent_socket, agent_http, default]. Should be a String.'
+    end
+
     private
 
     def validate_config_types
@@ -36,6 +60,27 @@ module Stackify
       validate_mode_type
     end
 
+    # Perform validation if transport type is default
+    # Required parameters are: env, app_name, api_key, log_level
+    def validate_default_transport
+      validate_app_name &&
+      validate_transport_type &&
+      validate_api_key &&
+      validate_env &&
+      validate_log_level &&
+      validate_mode_type
+    end
+
+    # Perform validation if transport type is agent_socket or agent_http
+    # Required parameters are: env, app_name, log_level
+    def validate_agent_transport
+      validate_env &&
+      validate_transport_type &&
+      validate_app_name &&
+      validate_log_level &&
+      validate_mode_type
+    end
+
     def validate_mode_type
       return true if @mode.is_a? Symbol
       @errors << 'Mode should be a Symbol'
@@ -43,7 +88,17 @@ module Stackify
 
     def validate_api_key
       return true if  @api_key.is_a?(String) && !@api_key.empty?
-      @errors << 'API_KEY should be a String and not empty'
+      @errors << 'Api_key should be a String and not empty'
+    end
+
+    def validate_app_name
+      return true if  @app_name.is_a?(String) && !@app_name.empty?
+      @errors << 'App_name should be a String and not empty'
+    end
+
+    def validate_env
+      return true if  @env.is_a?(Symbol) && !@env.empty?
+      @errors << 'Env should be a Symbol and not empty'
     end
 
     def validate_log_level

data/lib/stackify/utils/methods.rb

@@ -14,16 +14,20 @@ module Stackify::Utils
   end
 
   def self.do_only_if_authorized_and_mode_is_on mode, &block
-    if Stackify.configuration.api_enabled
-      if Stackify.authorized?
-        if is_mode_on? mode
-          yield
+    begin
+      if Stackify.configuration.api_enabled
+        if Stackify.authorized?
+          if is_mode_on? mode
+            yield
+          else
+            Stackify.internal_log :warn, "[Stackify::Utils] - #{caller[0]}: Skipped because mode - #{mode.to_s} is disabled at configuration"
+          end
         else
-          Stackify.internal_log :warn, "#{caller[0]}: Skipped because mode - #{mode.to_s} is disabled at configuration"
+          Stackify.internal_log :warn, "[Stackify::Utils] - #{caller[0]}: Skipped due to authorization failure"
         end
-      else
-        Stackify.internal_log :warn, "#{caller[0]}: Skipped due to authorization failure"
       end
+    rescue => ex
+      Stackify.internal_log :warn, "[Stackify::Utils] do_only_if_authorized_and_mode_is_on ex: #{ex.inspect}"
     end
   end
 
@@ -33,4 +37,38 @@ module Stackify::Utils
     found = exclude.select{|e| e =~ /#{cmd}/i}
     Stackify.configuration.api_enabled = false if found.count > 0
   end
-end
+
+  def self.get_app_settings
+    @env = {
+      'env' => Stackify.configuration.env,
+      'app_name' => Stackify.configuration.app_name,
+      'server_name' => Socket.gethostname,
+      'app_location' => Stackify.configuration.app_location || Dir.pwd
+    }
+  end
+
+  # Check if the app is running on rails and the logger output is using STDOUT
+  def self.check_log_output
+    if defined? Rails
+      if Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new('5.0')
+        Stackify.configuration.stdout_output = ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDOUT)
+      else
+        Stackify.configuration.stdout_output = self.logger_stdout
+      end
+    end
+  end
+
+  def self.logger_stdout
+    logdev = ::Rails.logger.instance_variable_get(:@logdev)
+    logger_source = logdev.dev if logdev.respond_to?(:dev)
+    sources = [$stdout]
+    found = sources.any? { |source| source == logger_source }
+  end
+
+  # Check if the rails version 3 and it's using the buffered logger
+  def self.check_buffered_logger
+    is_buffered_logger = false
+    is_buffered_logger = true if ::Rails.logger.is_a?(ActiveSupport::BufferedLogger)
+    Stackify.configuration.buffered_logger = is_buffered_logger
+  end
+end

data/lib/stackify/utils/protobuf_log_object.rb

@@ -0,0 +1,85 @@
+module Stackify
+  class ProtobufLogObject
+    def initialize level, msg, caller_str, trans_id=nil, log_uuid=nil, ex=nil
+      @level, @msg, @caller_str, @ex = level, msg, caller_str, ex, @trans_id = trans_id,
+      @log_uuid = log_uuid
+    end
+
+    # Create a LogMsgGroup Protobuf Object
+    def to_obj
+      begin
+        log = Stackify::LogGroup::Log.new
+        log.message = @msg
+        log.thread_name = Thread.current.object_id.to_s
+        log.date_millis = (Time.now.to_f * 1000).to_i
+        log.level = @level.to_s.upcase!
+        log.source_method = Stackify::Backtrace.method_name(@caller_str).to_s
+        log.source_line = Stackify::Backtrace.line_number(@caller_str).to_i
+        log.transaction_id = @trans_id unless @trans_id.nil?
+        log.id = @log_uuid unless @log_uuid.nil?
+        if @ex.try(:to_h)
+          ex = @ex.try(:to_h)
+          log_error = Stackify::LogGroup::Log::Error.new
+          log_error.date_millis = ex['OccurredEpochMillis'].to_i
+          if ex['EnvironmentDetail']
+            env = ex['EnvironmentDetail']
+            env_detail = Stackify::LogGroup::Log::Error::EnvironmentDetail.new
+            env_detail.device_name = env['DeviceName'].to_s
+            env_detail.application_name = env['AppName'].to_s
+            env_detail.application_location = env['AppLocation'].to_s
+            env_detail.configured_application_name = env['ConfiguredAppName'].to_s
+            env_detail.configured_environment_name = env['ConfiguredEnvironmentName'].to_s
+            log_error.environment_detail = env_detail
+          end
+          if ex['Error']
+            err = ex['Error']
+            error_item = Stackify::LogGroup::Log::Error::ErrorItem.new
+            error_item.message = err['Message'].to_s
+            error_item.error_type = err['ErrorType'].to_s
+            error_item.error_type_code = err['ErrorTypeCode'].to_s
+            if err['Data']
+              map_data = Google::Protobuf::Map.new(:string, :string)
+              err['Data'].each { |key, value| map_data["#{key}"] = value }
+              error_item.data = map_data
+            end
+            error_item.inner_error = err['InnerError']
+            error_item.source_method = err['SourceMethod'].to_s
+            if err['StackTrace']
+              stack = err['StackTrace']
+              stack.each do |stk|
+                trace_frame = Stackify::LogGroup::Log::Error::ErrorItem::TraceFrame.new
+                trace_frame.code_filename = stk['CodeFileName'].to_s
+                trace_frame.line_number = stk['LineNum'].to_i
+                trace_frame.method = stk['Method'].to_s
+                error_item.stacktrace.push(trace_frame)
+              end
+            end
+            log_error.error_item = error_item
+          end
+          if ex['WebRequestDetail']
+            req_details = ex['WebRequestDetail']
+            web_request = Stackify::LogGroup::Log::Error::WebRequestDetail.new
+            web_request.user_ip_address = req_details['UserIPAddress'].to_s
+            web_request.http_method = req_details['HttpMethod'].to_s
+            web_request.request_url = req_details['RequestUrl'].to_s
+            web_request.request_url_root = req_details['RequestUrlRoot'].to_s
+            web_request.referral_url = req_details['ReferralUrl'].to_s
+            web_request.post_data_raw = req_details['PostDataRaw'].to_s
+            log_error.web_request_detail = web_request
+          end
+          if !ex['ServerVariables'].empty?
+            map_server_vars = Google::Protobuf::Map.new(:string, :string)
+            ex['ServerVariables'].each { |key, value| map_server_vars["#{key.to_s}"] = value.to_s }
+            log_error.server_variables = map_server_vars
+          end
+
+          log.error = log_error
+        end
+        log
+      rescue => exception
+        Stackify.internal_log :info, "[ProtobufLogObject] Error: "
+        Stackify.internal_log :info, exception
+      end
+    end
+  end
+end

data/lib/stackify/version.rb

@@ -1,3 +1,3 @@
 module Stackify
-  VERSION = '1.0.15'
+  VERSION = '1.2.9'
 end

data/lib/stackify/workers/logs_sender_worker.rb

@@ -3,6 +3,16 @@ module Stackify
 
     def initialize name = 'LogsSender worker'
       super
+      case Stackify.configuration.transport
+      when Stackify::DEFAULT
+        name = 'LogsSender worker'
+      when Stackify::UNIX_SOCKET
+        name = 'UnixSocketSender worker'
+      when Stackify::AGENT_HTTP
+        name = 'AgentHTTPSender worker'
+      end
+      @name = name
+      @name += " ##{self.id}"
       @type = :logs_send
     end
 

data/stackify-api-ruby.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake', '~> 0'
   spec.add_runtime_dependency 'faraday', '~> 0.8'
+  spec.add_runtime_dependency 'net_http_unix', '~> 0.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stackify-api-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.15
+  version: 1.2.9
 platform: ruby
 authors:
 - Stackify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-16 00:00:00.000000000 Z
+date: 2020-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: net_http_unix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 description: Stackify Logs and Metrics API for Ruby
 email:
 - support@stackify.com
@@ -67,11 +81,14 @@ files:
 - README.md
 - Rakefile
 - lib/core_ext/core_ext.rb
-- lib/core_ext/fixnum.rb
 - lib/core_ext/object.rb
 - lib/generators/stackify/stackify_generator.rb
 - lib/generators/stackify/templates/stackify.rb
+- lib/proto/stackify-agent.rb
 - lib/stackify-api-ruby.rb
+- lib/stackify/agent_base_sender.rb
+- lib/stackify/agent_client.rb
+- lib/stackify/agent_http_sender.rb
 - lib/stackify/authorization/authorizable.rb
 - lib/stackify/authorization/authorization_client.rb
 - lib/stackify/engine.rb
@@ -94,10 +111,13 @@ files:
 - lib/stackify/schedule_delay.rb
 - lib/stackify/schedule_task.rb
 - lib/stackify/scheduler.rb
+- lib/stackify/transport_selector.rb
+- lib/stackify/unix_socket_sender.rb
 - lib/stackify/utils/backtrace.rb
 - lib/stackify/utils/configuration.rb
 - lib/stackify/utils/methods.rb
 - lib/stackify/utils/msg_object.rb
+- lib/stackify/utils/protobuf_log_object.rb
 - lib/stackify/version.rb
 - lib/stackify/workers/add_msg_worker.rb
 - lib/stackify/workers/auth_worker.rb

data/lib/core_ext/fixnum.rb

@@ -1,17 +0,0 @@
-class Fixnum
-  SECONDS_IN_MINUTE = 60
-  SECONDS_IN_HOUR =  60 * SECONDS_IN_MINUTE
-  SECONDS_IN_DAY = 24 * SECONDS_IN_HOUR
-
-  def days
-    self * SECONDS_IN_DAY
-  end
-
-  def minutes
-    self * SECONDS_IN_MINUTE
-  end
-
-  def ago
-    Time.now - self
-  end
-end