Ruby API - Add new transport AGENT_HTTP (#27)

* Ruby API - Add new transport AGENT_HTTP

Changes:
- added new transport http_agent
- refactor transport and reuse codes
- added option to get value from environment variables
- fix formatting
- remove unused requires
- fix typo

Author: jaygel179

lib/stackify-api-ruby.rb

@@ -10,7 +10,7 @@ module Stackify
   INTERNAL_LOG_PREFIX = '[Stackify]'.freeze
   STATUSES = { working: 'working', terminating: 'terminating', terminated: 'terminated'}
   MODES = { logging: :logging, metrics: :metrics, both: :both }
-  TRANSPORT = [DEFAULT = 'default', UNIX_SOCKET = 'agent_socket']
+  TRANSPORT = [DEFAULT = 'default', UNIX_SOCKET = 'agent_socket', AGENT_HTTP = 'agent_http']
 
   autoload :Backtrace,            'stackify/utils/backtrace'
   autoload :MsgObject,            'stackify/utils/msg_object'
@@ -29,10 +29,12 @@ module Stackify
   autoload :AddMsgWorker,         'stackify/workers/add_msg_worker'
   autoload :MsgsQueue,            'stackify/msgs_queue'
   autoload :LoggerClient,         'stackify/logger_client'
-  autoload :UnixSocketClient,     'stackify/unix_socket_client'
+  autoload :AgentClient,          'stackify/agent_client'
   autoload :TransportSelector,    'stackify/transport_selector'
   autoload :LogsSender,           'stackify/logs_sender'
+  autoload :AgentBaseSender,      'stackify/agent_base_sender'
   autoload :UnixSocketSender,     'stackify/unix_socket_sender'
+  autoload :AgentHTTPSender,      'stackify/agent_http_sender'
   autoload :LoggerProxy,          'stackify/logger_proxy'
   autoload :StackifiedError,      'stackify/error'
   autoload :StringException,      'stackify/error'
@@ -72,8 +74,8 @@ def logger_client
       @logger_client ||= Stackify::LoggerClient.new
     end
 
-    def unix_socket_client
-      @unix_socket_client ||= Stackify::UnixSocketClient.new
+    def agent_client
+      @agent_client ||= Stackify::AgentClient.new
     end
 
     def get_transport
@@ -145,7 +147,7 @@ def run
             else
               Stackify.log_internal_error "Stackify is not properly configured! Errors: #{Stackify.configuration.errors}"
             end
-          when Stackify::UNIX_SOCKET
+          when Stackify::UNIX_SOCKET, Stackify::AGENT_HTTP
             case Stackify.configuration.mode
             when MODES[:logging]
               start_logging

lib/stackify/agent_base_sender.rb

@@ -0,0 +1,54 @@
+#
+# This class will handle the sending of protobuf message to agent
+#
+module Stackify
+  class AgentBaseSender < Worker
+
+    # send_logs() Function to put the msg in the Worker
+    def send_logs msgs, attempts = 3
+      worker = Stackify::LogsSenderWorker.new('UnixSocketSender worker')
+      task = send_logs_task attempts, msgs
+      worker.async_perform ScheduleDelay.new, task
+    end
+
+    private
+
+    def properties
+      {
+        success_condition: lambda { |result| result.try(:status) == 200 },
+        limit: 1
+      }.dup
+    end
+
+    def send_logs_task attempts = nil, msgs
+      properties[:attempts] = attempts if attempts
+      Stackify::ScheduleTask.new properties do
+        data = create_log_group msgs
+        send_request data
+      end
+    end
+
+    # create_log_group() This function will create a log group protobuf object
+    # @msgs {Object} Protobuf message
+    # return {Object} Return an object
+    def create_log_group msgs
+      # @details {Object} it will return the properties based in Stackify.setup() configuration
+      details = Stackify::Utils.get_app_settings
+      log_group = Stackify::LogGroup.new
+      msgs.each do |msg|
+        log_group.logs << msg
+      end
+      log_group.environment = details['env']
+      log_group.server_name = details['server_name']
+      log_group.application_name = details['app_name']
+      log_group.application_location = details['app_location']
+      log_group.logger = 'Ruby logger'
+      log_group.platform = 'ruby'
+      log_group
+    end
+
+    def send_request log_group
+      raise NotImplementedError
+    end
+  end
+end

lib/stackify/unix_socket_client.rb lib/stackify/agent_client.rblib/stackify/unix_socket_client.rb renamed to lib/stackify/agent_client.rb

@@ -1,10 +1,15 @@
 module Stackify
-  class UnixSocketClient
+  class AgentClient
 
     def initialize
-      Stackify.internal_log :info, '[UnixSocketClient]: initialize()'
+      Stackify.internal_log :info, '[AgentClient]: initialize()'
       @@errors_governor = Stackify::ErrorsGovernor.new
-      @@sender = Stackify::UnixSocketSender.new
+      case Stackify.configuration.transport
+        when Stackify::UNIX_SOCKET
+          @@sender = Stackify::UnixSocketSender.new
+        when Stackify::AGENT_HTTP
+          @@sender = Stackify::AgentHTTPSender.new
+        end
     end
 
     def log level, msg, call_trace, task
@@ -22,11 +27,11 @@ def log_exception level= :error, ex, task
             worker.async_perform ScheduleDelay.new, task
           else
             Stackify.internal_log :warn,
-            "UnixSocketClient: logging of exception with message \"#{ex.message}\" is skipped - flood_limit is exceeded"
+            "AgentClient: logging of exception with message \"#{ex.message}\" is skipped - flood_limit is exceeded"
           end
         end
       else
-        Stackify.log_internal_error 'UnixSocketClient: log_exception should get StackifiedError object'
+        Stackify.log_internal_error 'AgentClient: log_exception should get StackifiedError object'
       end
     end
 

lib/stackify/agent_http_sender.rb

@@ -0,0 +1,41 @@
+require 'uri'
+require 'faraday'
+require 'ostruct'
+
+#
+# This class will handle the sending of protobuf message to agent using http request
+#
+module Stackify
+  class AgentHTTPSender < AgentBaseSender
+
+    HEADERS = {
+      'Content-Type' => 'application/x-protobuf'
+    }
+
+    # send_request() This function will post an http request
+    # @msgs {Object} Protobuf message
+    # return {Object} Return an object {status, message}
+    def send_request log_group
+      begin
+        # Convert data into binary and send it to agent
+        message = Stackify::LogGroup.encode(log_group)
+        conn = Faraday.new(proxy: Stackify.configuration.proxy)
+        @response = conn.post do |req|
+          req.url URI(Stackify.configuration.http_endpoint + Stackify.configuration.agent_log_url)
+          req.headers = HEADERS
+          req.body = message
+        end
+        if @response.try(:status) == 200
+          Stackify.internal_log :debug, "[AgentHTTPSender]: Successfully send message via unix domain socket."
+          return OpenStruct.new({status: 200, msg: 'OK'})
+        else
+          Stackify.internal_log :debug, "[AgentHTTPSender] Sending failed."
+          return OpenStruct.new({status: 500, msg: 'Not OK'})
+        end
+      rescue => exception
+        Stackify.log_internal_error "[AgentHTTPSender] send_logs() Error: #{exception}"
+        return OpenStruct.new({status: 500, msg: exception})
+      end
+    end
+  end
+end

lib/stackify/msgs_queue.rb

@@ -52,7 +52,7 @@ def add_msg msg
           Stackify::Utils.do_only_if_authorized_and_mode_is_on Stackify::MODES[:logging] do
             old_push(msg)
           end
-        when Stackify::UNIX_SOCKET
+        when Stackify::UNIX_SOCKET, Stackify::AGENT_HTTP
           old_push(msg)
         end
       end

lib/stackify/transport_selector.rb

@@ -9,9 +9,9 @@ def initialize type
         Stackify::Utils.do_only_if_authorized_and_mode_is_on Stackify::MODES[:logging] do
           @transport = Stackify::LogsSender.new
         end
-      when Stackify::UNIX_SOCKET
-        @transport = Stackify::UnixSocketClient.new
+      when Stackify::UNIX_SOCKET, Stackify::AGENT_HTTP
+        @transport = Stackify::AgentClient.new
       end
     end
   end
-end
+end

lib/stackify/unix_socket_sender.rb

@@ -5,50 +5,7 @@
 # This class will handle the sending of protobuf message to unix domain socket
 #
 module Stackify
-  class UnixSocketSender < Worker
-
-    # send_logs() Function to put the msg in the Worker
-    def send_logs msgs, attempts = 3
-      worker = Stackify::LogsSenderWorker.new('UnixSocketSender worker')
-      task = send_logs_task attempts, msgs
-      worker.async_perform ScheduleDelay.new, task
-    end
-
-    private
-
-    def properties
-      {
-        success_condition: lambda { |result| result.try(:status) == 200 },
-        limit: 1
-      }.dup
-    end
-
-    def send_logs_task attempts = nil, msgs
-      properties[:attempts] = attempts if attempts
-      Stackify::ScheduleTask.new properties do
-        data = create_log_group msgs
-        send_request data
-      end
-    end
-
-    # create_log_group() This function will create a log group protobuf object
-    # @msgs {Object} Protobuf message
-    # return {Object} Return an object
-    def create_log_group msgs
-      # @details {Object} it will return the properties based in Stackify.setup() configuration
-      details = Stackify::Utils.get_app_settings
-      log_group = Stackify::LogGroup.new
-      msgs.each do |msg|
-        log_group.logs << msg
-      end
-      log_group.environment = details['env']
-      log_group.server_name = details['server_name']
-      log_group.application_name = details['app_name']
-      log_group.application_location = details['app_location']
-      log_group.logger = 'Ruby logger'
-      log_group.platform = 'ruby'
-      log_group
-    end
+  class UnixSocketSender < AgentBaseSender
 
     # send_request() This function will send http request via unix domain socket
     # @msgs {Object} Protobuf message
@@ -58,7 +15,7 @@ def send_request log_group
         # Convert data into binary and send it to unix domain socket
         message = Stackify::LogGroup.encode(log_group)
         client = NetX::HTTPUnix.new('unix://' + Stackify.configuration.unix_socket_path)
-        req = Net::HTTP::Post.new(Stackify.configuration.unix_socket_url)
+        req = Net::HTTP::Post.new(Stackify.configuration.agent_log_url)
         req.set_content_type('application/x-protobuf')
         req.body = message
         response = client.request(req)

lib/stackify/utils/configuration.rb

@@ -3,16 +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, :transport, :errors
+                  :proxy, :mode, :base_api_url, :api_enabled, :transport, :errors, :http_endpoint
 
-    attr_reader :send_interval, :flood_limit, :queue_max_size, :unix_socket_path, :unix_socket_url
+    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 = 'default'
+      @transport = get_env 'STACKIFY_TRANSPORT', 'default'
       @env = :production
       @flood_limit = 100
       @queue_max_size = 10000
@@ -22,23 +22,32 @@ def initialize
       @mode = MODES[:both]
       @logger = Logger.new(STDOUT)
       @logger.level = Logger::UNKNOWN
+      @agent_log_url = '/log'
       @unix_socket_path = '/usr/local/stackify/stackify.sock'
-      @unix_socket_url = '/log'
+      @http_endpoint = get_env 'STACKIFY_TRANSPORT_HTTP_ENDPOINT', 'https://localhost:10601'
+    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?
       case Stackify.configuration.transport
       when Stackify::DEFAULT
         validate_default_transport
-      when Stackify::UNIX_SOCKET
-        validate_unix_domain_socket_transport
+      when Stackify::UNIX_SOCKET, Stackify::AGENT_HTTP
+        validate_agent_transport
       end
       @errors.empty?
     end
 
     def validate_transport_type
-      return true if ['agent_socket', 'default'].include? @transport
-      @errors << 'Transport should be one of these values: [agent_socket, default]. Should be a String.'
+      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
@@ -60,9 +69,9 @@ def validate_default_transport
       validate_mode_type
     end
 
-    # Perform validation if transport type is agent_socket
+    # Perform validation if transport type is agent_socket or agent_http
     # Required parameters are: env, app_name, log_level
-    def validate_unix_domain_socket_transport
+    def validate_agent_transport
       validate_env &&
       validate_transport_type &&
       validate_app_name &&