coralogix_logger 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c6cd392cb48af14a79cb7cf58d901c7d4e1b976e
+  data.tar.gz: db4691005c5c7d2056c24ab830d2225ba46d0157
+SHA512:
+  metadata.gz: 955a9052ecceab5a80b59630272fb04ad09920c3488783f9c7530ec940ad873461720fde9a35716eb83a92bc0b7b3af5c860593c0b776f88d48cdf47f5d0853b
+  data.tar.gz: 63d0f88dc5404058e9ed03d659f79ec0fd21b7589f6f1f4b4c6e4e5bb989b43e210e6c0d099f5f97eb5883a557e22d8ab29272e326a5156c945ff9363e9f2018

data/README.md

@@ -0,0 +1,63 @@
+
+# Croalogix SDK - Ruby Implementation
+This is an implementation of Coralogix Ruby SDK.
+
+## INSTALL
+gem install coralogix_logger
+
+
+## GENERAL
+
+**Private Key** - A unique ID which represents your company, this Id will be sent to your mail once you register to Coralogix.
+
+**Application Name** - The name of your main application, for example, a company named “SuperData” would probably insert the “SuperData” string parameter or if they want to debug their test environment they might insert the  “SuperData– Test”.
+
+**SubSystem Name** - Your application probably has multiple subsystems, for example: Backend servers, Middleware, Frontend servers etc. in order to help you examine the data you need, inserting the subsystem parameter is vital.
+
+
+
+## USAGE
+
+You must provide the following four variables when creating a Coralogix logger instance.
+
+**Private Key** - A unique ID which represents your company, this Id will be sent to your mail once you register to Coralogix.
+
+**Application Name** - The name of your main application, for example, a company named “SuperData” would probably insert the “SuperData” string parameter or if they want to debug their test environment they might insert the  “SuperData– Test”.
+
+**SubSystem Name** - Your application probably has multiple subsystems, for example: Backend servers, Middleware, Frontend servers etc. in order to help you examine the data you need, inserting the subsystem parameter is vital.
+
+##### Example: Coralogix SDK ####
+    require 'coralogix_logger'
+
+    PRIVATE_KEY = "11111111-1111-1111-1111-111111111111"    
+    APP_NAME = "MyTestApp"  
+    SUB_SYSTEM = "BL"     
+
+    Coralogix::CoralogixLogger.configure(PRIVATE_KEY, APP_NAME, SUB_SYSTEM)
+
+    #The common practice is to get an instance of the logger in each class and setting the logger name to the class name.
+    logger = Coralogix::CoralogixLogger.get_logger("category1")
+    
+    #Send "Hello World!" message with severity verbose. 
+    logger.log(Coralogix::Severity::VERBOSE, "Hello World!")
+
+    #Additional options
+    #Severity, category and message parameters are mandatory. The rest of the parameters are optional.
+    #If category is not specified, logger name will be used instead
+    logger.log(Coralogix::Severity::DEBUG, "Hello World!", category: "my category")
+    logger.log(Coralogix::Severity::INFO, "Hello World!", category: "my category", className: "my class")
+    logger.log(Coralogix::Severity::WARNING, "Hello World!", category: "my category", className: "my class", methodName: "my method")
+    logger.log(Coralogix::Severity::ERROR, "Hello World!", category: "my category", className: "my class", methodName: "my method", threadId: "thread id")
+    logger.log(Coralogix::Severity::CRITICAL, "Hello World!", className: "my class", methodName: "my method", threadId: "thread id")
+
+
+    #Using severity methods
+    #Only message is mandatory. The rest of the parameters are optional.
+    logger.debug("Hello World!")
+    logger.verbose("Hello World!", className: "my class")
+    logger.info("Hello World!", className: "my class", methodName: "my method")
+    logger.warning("Hello World!", className: "my class", methodName: "my method", threadId="thread id")
+    logger.error("Hello World!", className: "my class", methodName: "my method", threadId="thread id")
+    logger.critical("Hello World!", category: "my category", className: "my class", methodName: "my method", threadId="thread id")
+
+

data/lib/constants.rb

@@ -0,0 +1,53 @@
+module Coralogix
+
+    #Maximum log buffer size
+    MAX_LOG_BUFFER_SIZE = 12582912 #12mb
+
+    #Maximum chunk size
+    MAX_LOG_CHUNK_SIZE = 1572864 #1.5 mb
+
+    #Bulk send interval in normal mode.
+    NORMAL_SEND_SPEED_INTERVAL = 500.0 / 1000
+
+    #Bulk send interval in fast mode.
+    FAST_SEND_SPEED_INTERVAL = 100.0 / 1000
+
+    #Corologix severity mapper
+    SEVERITIES = {:debug => 1, :verbose => 2, :info => 3, :warning => 4, :error => 5, :critical => 6}
+
+
+    module Severity
+        DEBUG = 1
+        VERBOSE = 2
+        INFO = 3
+        WARNING = 4
+        ERROR = 5
+        CRITICAL = 6
+    end
+
+
+    #Coralogix logs url
+    CORALOGIX_LOG_URL = "https://api.coralogix.com:443/api/v1/logs"
+
+    #Default private key
+    FAILED_PRIVATE_KEY = "9626c7dd-8174-5015-a3fe-5572e042b6d9"
+
+    #Default application name
+    FAILED_APP_NAME = "FAILED_APP_NAME"  
+
+    #Default subsystem name
+    FAILED_SUB_SYSTEM = "FAILED_SUB_NAME"
+
+    #Default log file name
+    LOG_FILE_NAME = "coralogix.sdk.log"
+
+    #Default http timeout
+    HTTP_TIMEOUT = 30
+
+    #Number of attempts to retry http post
+    HTTP_SEND_RETRY_COUNT = 5
+
+    #Interval between failed http post requests
+    HTTP_SEND_RETRY_INTERVAL = 2
+
+end

data/lib/coralogix_logger.rb

@@ -0,0 +1,90 @@
+require_relative 'manager'
+require_relative 'debug_logger'
+require_relative 'httpsender'
+require_relative 'constants'
+
+module Coralogix
+
+    class CoralogixLogger
+        # Set 'new' method to be a private method. 
+        # This way it won't be possible to create a new intance of this class from outside.
+        private_class_method :new
+
+        # Constructor. 
+        #
+        # @param name    -   logger name.
+        def initialize name
+            @category = name
+        end
+
+        # A getter for debug_mode. 
+        # Default value is false.
+        # When set to true the coralogix logger will print output messages to a console and a file.
+        #
+        # @return [boolean]    -   true or false. (Default is false)
+        def self.debug_mode?
+            DebugLogger.debug_mode
+        end
+
+        # A setter for debug_mode. 
+        # Default value is false.
+        # When set to true the coralogix logger will print output messages to a console and a file.
+        #
+        # @param value    -   true or false. (Default is false)
+        def self.debug_mode=(value)
+            DebugLogger.debug_mode=value
+        end
+
+        # A setter for disable_proxy. 
+        # By default HTTP object will use proxy environment variable if exists. In some cases this migh be an issue
+        # When set to false the HTTP object will ignore any proxy.
+        #
+        # @param value    -   true or false. (Default is false)
+        def self.disable_proxy=(value)
+            CoralogixHTTPSender.disable_proxy=value
+        end
+
+        # A class method (static) to return a new instance of the current class.
+        # This is the most common pattern when using logging.
+        #
+        # @param name    -   name of the logger. The category. Usually this will be a new name for every class or a logical unit.
+        # @return [CoralogixLogger] return a new instance of CoralogixLogger.
+        def self.get_logger name
+            #Return a new instance of the current class.
+            CoralogixLogger.send(:new, name)
+        end
+
+        # Configure coralogix logger with customer specific values
+        #
+        # @param private_key    -   private key
+        # @param app_name       -   application name
+        # @param sub_system     -   sub system name
+        # @return [boolean] return a true or false.
+        def self.configure private_key, app_name, sub_system
+            LoggerManager.configure(:privateKey => private_key, :applicationName => app_name, :subsystemName => sub_system) unless LoggerManager.configured
+        end
+
+        # Log a message. 
+        #
+        # @param severity    -   log severity
+        # @param message     -   log message
+        # @param category    -   log category
+        # @param className   -   log class name
+        # @param methodName  -   log method name
+        # @param threadId    -   log thread id
+        def log severity, message, category: @category, className: "", methodName: "", threadId: ""
+            LoggerManager.add_logline message, severity, category, :className => className, :methodName => methodName, :threadId => threadId
+        end 
+
+        # Create log methods for each severity. 
+        # This is a ruby thing. If you are writing in other languages just create a method for each severity.
+        # For instance, for info severity it will create a method:
+        # def info message, category: @category, className: "", methodName: "", threadId: ""
+        SEVERITIES.keys.each do |severity|
+            define_method("#{severity}") do |message, category: @category, className: "", methodName: "", threadId: ""|
+                LoggerManager.add_logline message, SEVERITIES["#{__method__}".to_sym], category, :className => className, :methodName => methodName, :threadId => threadId
+            end  
+        end
+    end
+
+end

data/lib/debug_logger.rb

@@ -0,0 +1,56 @@
+require 'logger'
+
+module Coralogix
+    # @private
+    class DebugLogger
+
+        def self.initialize
+            begin
+                @mutex = Mutex.new
+                @debug = false
+            rescue Exception => e
+                if @debug  
+                    puts e.message  
+                    puts e.backtrace.inspect  
+                end
+            end
+        end 
+
+        def self.debug_mode?
+            @debug
+        end
+
+        def self.debug_mode=(value)
+            begin
+                @debug = value
+                if value
+                    @logger = Logger.new(LOG_FILE_NAME, 1, 10485760)
+                else
+                    @logger.close unless @logger == nil
+                    @logger = nil
+                end
+            rescue Exception => e
+                if @debug  
+                    puts e.message  
+                    puts e.backtrace.inspect  
+                end
+            end
+        end
+
+        Logger::Severity.constants.each do |level|
+            define_singleton_method("#{level.downcase}") do |*args|
+                @mutex.synchronize do
+                    if @debug
+                        puts "#{__method__.upcase}:  #{Time.now.strftime('%H:%M:%S.%L')} - #{args}"
+                        @logger.send("#{__method__}", args)
+                    end
+                end
+            end  
+        end
+
+
+        initialize
+    
+    end
+
+end

data/lib/httpsender.rb

@@ -0,0 +1,73 @@
+require 'net/http'
+require 'json'
+require_relative 'constants'
+require_relative 'debug_logger'
+require 'openssl'
+require 'benchmark'
+
+module Coralogix
+    # @private
+    module CoralogixHTTPSender
+        
+        @initialized = false
+        
+        def CoralogixHTTPSender.disable_proxy value
+            @disable_proxy = value
+        end
+
+        def CoralogixHTTPSender.disable_proxy=(value)
+            @disable_proxy = value
+        end
+
+        def CoralogixHTTPSender.initialize
+            begin
+                @uri = URI(CORALOGIX_LOG_URL)
+                if(@disable_proxy)
+                    #@http = Net::HTTP.start(@uri.host, @uri.port, p_addr=nil, p_port=nil, :use_ssl => true, :verify_mode=> OpenSSL::SSL::VERIFY_NONE)
+                    @http = Net::HTTP.new(@uri.host, @uri.port, p_addr=nil, p_port=nil)
+                else
+                    #@http = Net::HTTP.start(@uri.host, @uri.port, :use_ssl => true, :verify_mode=> OpenSSL::SSL::VERIFY_NONE)
+                    @http = Net::HTTP.new(@uri.host, @uri.port)
+                end
+                @http.use_ssl = true
+                @http.keep_alive_timeout = 10
+                @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+                @http.read_timeout = HTTP_TIMEOUT # seconds
+                @req = Net::HTTP::Post.new(@uri.path, 'Content-Type' => 'application/json')
+                @initialized = true
+            rescue Exception => e  
+                    DebugLogger.error e.message  
+                    DebugLogger.error e.backtrace.inspect  
+                    @initialized = false
+            end
+            return @initialized
+        end
+
+        # A helper method to post http request
+        #
+        # @param bulk    -   JSON bulk containing the log entries
+        def CoralogixHTTPSender.send_request bulk
+            
+            self.initialize unless @initialized
+            attempt = 0
+            while attempt < HTTP_SEND_RETRY_COUNT
+                begin
+                    DebugLogger.info "About to send bulk to Coralogix server. Attempt number: #{attempt+1}"  
+                    @req.body = bulk.to_json
+                    DebugLogger.debug Benchmark.measure { 
+                        res = @http.request(@req)
+                        DebugLogger.info "Successfully sent bulk to Coralogix server. Result is: #{res.code}"
+                    }.to_s
+                    return true
+                rescue Exception => e  
+                    DebugLogger.error e.message  
+                    DebugLogger.error e.backtrace.inspect  
+                end
+                attempt+=1;
+                DebugLogger.error "Failed to send bulk. Will retry in: #{HTTP_SEND_RETRY_INTERVAL} seconds..."
+                sleep HTTP_SEND_RETRY_INTERVAL
+            end
+        end
+    end
+
+end

data/lib/manager.rb

@@ -0,0 +1,128 @@
+#require 'net/http'
+#require 'json'
+require_relative 'httpsender'
+require_relative 'constants'
+require_relative 'debug_logger'
+#require "benchmark"
+
+module Coralogix
+    # @private
+    class LoggerManager
+
+        class << self
+            attr_accessor :configured
+        end
+
+        def self.initialize
+            @buffer = []
+            @buffer_size = 0
+            @bulk_template = {:privateKey => FAILED_PRIVATE_KEY, :applicationName => FAILED_APP_NAME, :subsystemName => FAILED_SUB_SYSTEM}
+            @mutex = Mutex.new
+            self.run
+        end
+
+        # Add a log line to our buffer.
+        #
+        # @param **args    -   Customer parameters:
+        #                           privateKey - Private Key
+        #                           applicationName - Application name
+        #                           subsystemName - Subsystem name
+        # @return [boolean] return true for success or false for failure.
+        def self.configure **args
+            begin
+                @bulk_template = args.merge({:computerName => `hostname`.strip})
+                configured = true
+            rescue
+                return false
+            end
+        end
+
+        # Add a log line to our buffer.
+        #
+        # @param message    -   The logs message. This is a must parameter.
+        # @param severity   -   The severity of the log message. This is a must parameter.
+        # @param category   -   The category (logger name) of the message. This is a must parameter.
+        # @param **args     -   Optional parameters. It can be:
+        #                           className - The class name where the log message was sent from.
+        #                           methodName - The method name where the log message was sent from.
+        #                           threadId -  The thread id where the log message was sent from.
+        # @return [boolean] return true for success or false for failure.
+        def self.add_logline message, severity, category, **args
+            begin
+                @mutex.synchronize do
+                    if @buffer_size < MAX_LOG_BUFFER_SIZE
+                        #Combine a logentry from the must parameters together with the optional one.
+                        new_entry = {:text => message, :timestamp => Time.now.utc.to_f * 1000, :severity => severity, :category => category}.merge(args)
+                        @buffer << new_entry
+                        #Updte the buffer size to reflect the new size.
+                        @buffer_size+=new_entry.to_json.bytesize
+                    else
+                        DebugLogger.warn "Buffer is full. Ignoring current message."
+                    end
+                end
+            rescue Exception => e  
+                DebugLogger.error e.message  
+                DebugLogger.error e.backtrace.inspect
+                return false
+            end
+            return true
+        end
+
+        # Send bulk from the buffer
+        def self.send_bulk
+            begin
+                @mutex.synchronize do
+                    # Total buffer size
+                    size = @buffer.size
+
+                    # If the size is bigger than the maximum allowed chunk size then split it by half.
+                    # Keep splitting it until the size is less than MAX_LOG_CHUNK_SIZE
+                    while @buffer.take(size).join(",").bytesize > MAX_LOG_CHUNK_SIZE
+                        size=size/2;
+                    end
+
+                    DebugLogger.info "Checking buffer size. Total log entries is: #{size}"
+                    @bulk_template[:logEntries] = @buffer.shift(size)
+
+                    # Extract from the buffer size the total amount of the logs we removed from the buffer
+                    @buffer_size-= (@bulk_template[:logEntries].to_json.bytesize - 2 - size-1)
+
+                    DebugLogger.info "Bufer size after removal is: #{@buffer.join(",").bytesize}"
+                end
+                CoralogixHTTPSender.send_request(@bulk_template) unless @bulk_template[:logEntries].empty?
+            rescue Exception => e  
+                DebugLogger.error e.message  
+                DebugLogger.error e.backtrace.inspect  
+            end
+        end
+
+        # Start timer execution.
+        # The timer should send every X seconds logs from the buffer.
+        def self.run
+            begin
+                timer_thread = Thread.new do
+                    while true
+                        # Send log bulk
+                        self.send_bulk
+
+                        # Check when is the next time we should send logs?
+                        # If we already have at least half of the max chunk size then we are working in fast mode
+                        next_check_interval = @buffer_size > (MAX_LOG_CHUNK_SIZE / 2) ? FAST_SEND_SPEED_INTERVAL : NORMAL_SEND_SPEED_INTERVAL
+                        DebugLogger.debug "Next buffer check is scheduled in #{next_check_interval} seconds"
+                        sleep next_check_interval
+                    end
+                end
+
+                #Set thread priority to a high number
+                timer_thread.priority = 100
+            rescue Exception => e  
+                DebugLogger.error e.message  
+                DebugLogger.error e.backtrace.inspect
+                return false
+            end
+        end
+
+        initialize
+    end
+
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: coralogix_logger
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Royee Goldberg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-29 00:00:00.000000000 Z
+dependencies: []
+description: Coralogix ruby sdk to send logs to Coralogix server.
+email: royee@coralogix.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/constants.rb
+- lib/coralogix_logger.rb
+- lib/debug_logger.rb
+- lib/httpsender.rb
+- lib/manager.rb
+homepage: http://www.coralogix.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Coralogix Ruby Logger SDK
+test_files: []