logdna 1.2.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6222bf49a91e32f57729e06f85badea969f6bacb
-  data.tar.gz: 0b33b7292fa1072b81f978f07f331b369eabc9ee
+SHA256:
+  metadata.gz: 32488a458ed8004dcb65531121c286ae1df1b5b3586cf146bb5e973e24e0f559
+  data.tar.gz: 03f487fbff81de61177296ec51849659c66391d7f16a00a2d170e7d03971eaf9
 SHA512:
-  metadata.gz: 73b0894e04ca5246b7d2906a8b333f947b4c43c750938f7cb8c06ae3610bedd1b43bc3bc94a661ff4a54bf768279d1404abd4d76f258893aba3effb7dc09afe8
-  data.tar.gz: 5d47c9ec27b2e620c7967d03312e1209b47cfb57107f480613f611e85d98400ec120572e4788d55d9301740c9a302daa7d43bcf7eb79cb5ba362bddc87d7322a
+  metadata.gz: 5a525a02bc844af91ecc52e324ebc9c1323c26ff0fada9cfb32092b9d57f84b7c8dacd7239e8ffb4d36caca3b89533b0fac577a17e3264643c2678368b7abc10
+  data.tar.gz: fa9721cf9605ab44e08d6222a3d8a222c0c0b3eca7802db673ab7a2c3c8bc840ddb060197a39ddb7b5aa149b93fc26d197c09c7c10a54e84f4579d00f7b8ed61

data/{LICENSE.txt → LICENSE}

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 edwin-lai
+Copyright (c) 2019 LogDNA
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,13 +9,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -48,9 +48,10 @@ Options are optional variables that may contain hostname, app name, mac address,
         :ip =>  myIpAddress,
         :mac => myMacAddress,
         :app => myAppName,
-        :level => "INFO",    # LOG_LEVELS = ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL'] or your customized log level
+        :level => "INFO",    # LOG_LEVELS = ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL'] or your customized log level (custom levels for Rails have to be sent with a log message)
         :env => "PRODUCTION",
-        :meta => {:once => {:first => "nested1", :another => "nested2"}}
+        :meta => {:once => {:first => "nested1", :another => "nested2"}},
+        :endpoint => "https://fqdn/logs/ingest"
     }
 
 To send logs, use "log" method. Default log level is "INFO"
@@ -80,7 +81,6 @@ Clear current metadata, level, appname, environment
     logger.clear
 
 Check current log level:
-    
     logger.info? => true
     logger.warn? => false
 
@@ -93,12 +93,19 @@ Log a message with a particular level easily
 
 Hostname and app name cannot be more than 80 characters.
 
+### Rails Setup
+In your `config/environments/environment.rb`:
+
+  ```
+  Rails.application.configure do
+    config.logger = Logdna::Ruby.new(your_api_key, options)
+  end
+  ```
 
 # Important Notes
 
 1. This logger assumes that you pass in json formatted data
-2. This logger is a singleton (do not create mutiple instances of the logger) even though the singleton structure is not strongly enforced. 
-
+2. This logger is a singleton (do not create mutiple instances of the logger) even though the singleton structure is not strongly enforced.
 
 # API
 
@@ -115,10 +122,15 @@ Instantiates a new instance of the class it is called on. ingestion_key is requi
 |{ :level => Log level } | 'INFO' |
 |{ :env => STAGING, PRODUCTION .. etc} | Nil |
 |{ :meta => metadata} | Nil |
-|{ :flushtime => Log flush interval in seconds } | 0.25 seconds |
-|{ :flushbyte => Log flush upper limit in bytes } | 500000 bytes ~= 0.5 megabytes |
-
-Different log level displays log messages in different colors as well. 
+|{ :endpoint => LogDNA Ingestion URI | 'https://logs.logdna.com/logs/ingest' |
+|{ :flush_interval => Limit to trigger a flush in seconds } | 0.25 seconds |
+|{ :flush_size => Limit to trigger a flush in bytes } | 2097152 bytes = 2 MiB |
+|{ :request_size => Upper limit of request in bytes } | 2097152 bytes = 2 MiB |
+|{ :retry_timeout => Base timeout for retries in seconds } | 0.25 seconds |
+|{ :retry_max_attempts => Maximum number of retries per request } | 3 attempts |
+|{ :retry_max_jitter => Maximum amount of jitter to add to each retry request in seconds } | 0.25 seconds |
+
+Different log level displays log messages in different colors as well.
 - ![TRACE DEBUG INFO Colors](https://placehold.it/15/515151/000000?text=+)   "Trace"  "Debug"  "Info"
 - ![WARN Color](https://placehold.it/15/ec9563/000000?text=+)   "Warn"
 - ![ERROR Fatal Colors](https://placehold.it/15/e37e7d/000000?text=+)   "Error"  "Fatal"

data/lib/logdna.rb

@@ -1,157 +1,133 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-# require 'singleton'
-require 'socket'
-require 'uri'
-require_relative 'logdna/client.rb'
-require_relative 'logdna/resources.rb'
+# frozen_string_literal: true
+
+require "logger"
+require "socket"
+require "uri"
+require_relative "logdna/client"
+require_relative "logdna/resources"
+require_relative "logdna/version"
+
 module Logdna
   class ValidURLRequired < ArgumentError; end
+
   class MaxLengthExceeded < ArgumentError; end
 
   class Ruby < ::Logger
     # uncomment line below and line 3 to enforce singleton
     # include Singleton
     Logger::TRACE = 5
-    attr_accessor :level, :app, :env, :meta
+    attr_accessor :app, :env, :meta
 
-    def initialize(key, opts={})
-      @app = opts[:app] || 'default'
-      @level = opts[:level] || 'INFO'
+    def initialize(key, opts = {})
+      super(nil, nil, nil)
+      @app = opts[:app] || "default"
+      @log_level = opts[:level] || "INFO"
       @env = opts[:env]
       @meta = opts[:meta]
-      @@client = nil unless defined? @@client
-
+      @internal_logger = Logger.new($stdout)
+      @internal_logger.level = Logger::DEBUG
+      endpoint = opts[:endpoint] || Resources::ENDPOINT
       hostname = opts[:hostname] || Socket.gethostname
-      ip =  opts.key?(:ip) ? "&ip=#{opts[:ip]}" : ''
-      mac = opts.key?(:mac) ? "&mac=#{opts[:mac]}" : ''
-      url = "#{Resources::ENDPOINT}?hostname=#{hostname}#{mac}#{ip}"
-
-      begin
-        if (hostname.size > Resources::MAX_INPUT_LENGTH || @app.size > Resources::MAX_INPUT_LENGTH )
-            raise MaxLengthExceeded.new
-        end
-      rescue MaxLengthExceeded => e
-        puts "Hostname or Appname is over #{Resources::MAX_INPUT_LENGTH} characters"
-        handle_exception(e)
-        return
-      end
 
-      begin
-        uri = URI(url)
-      rescue URI::ValidURIRequired => e
-        puts "Invalid URL Endpoint: #{url}"
-        handle_exception(e)
+      if hostname.size > Resources::MAX_INPUT_LENGTH || @app.size > Resources::MAX_INPUT_LENGTH
+        @internal_logger.debug("Hostname or Appname is over #{Resources::MAX_INPUT_LENGTH} characters")
         return
       end
 
-      begin
-        request = Net::HTTP::Post.new(uri.request_uri, 'Content-Type' => 'application/json')
-        request.basic_auth 'username', key
-      rescue => e
-        handle_exception(e)
-        return
-      end
-
-      @@client = Logdna::Client.new(request, uri, opts)
-    end
+      ip =  opts.key?(:ip) ? "&ip=#{opts[:ip]}" : ""
+      mac = opts.key?(:mac) ? "&mac=#{opts[:mac]}" : ""
+      url = "#{endpoint}?hostname=#{hostname}#{mac}#{ip}"
+      uri = URI(url)
 
-    def handle_exception(e)
-      exception_message = e.message
-      exception_backtrace = e.backtrace
-      # NOTE: should log with Ruby logger?
-      puts exception_message
+      request = Net::HTTP::Post.new(uri.request_uri, "Content-Type" => "application/json")
+      request.basic_auth("username", key)
+      request[:'user-agent'] = opts[:'user-agent'] || "ruby/#{LogDNA::VERSION}"
+      @client = Logdna::Client.new(request, uri, opts)
     end
 
     def default_opts
       {
         app: @app,
-        level: @level,
+        level: @log_level,
         env: @env,
         meta: @meta,
       }
     end
 
+    def level
+      @log_level
+    end
+
     def level=(value)
       if value.is_a? Numeric
-        @level = Resources::LOG_LEVELS[value]
+        @log_level = Resources::LOG_LEVELS[value]
         return
       end
 
-      @level = value
+      @log_level = value
     end
 
-    def log(msg=nil, opts={})
-      loggerExist?
-      message = yield if msg.nil? && block_given?
-      @response = @@client.buffer(message, default_opts.merge(opts).merge({
-            timestamp: (Time.now.to_f * 1000).to_i
-        }))
-      'Saved'
+    def log(message = nil, opts = {})
+      if message.nil? && block_given?
+        message = yield
+      end
+      if message.nil?
+        @internal_logger.debug("provide either a message or block")
+        return
+      end
+      message = message.to_s.encode("UTF-8")
+      @client.write_to_buffer(message, default_opts.merge(opts).merge(
+                                         timestamp: (Time.now.to_f * 1000).to_i
+                                       ))
     end
 
     Resources::LOG_LEVELS.each do |lvl|
       name = lvl.downcase
 
-      define_method name do |msg=nil, opts={}, &block|
-        self.log(msg, opts.merge({
-          level: lvl,
-        }), &block)
+      define_method name do |msg = nil, opts = {}, &block|
+        self.log(msg, opts.merge(
+                        level: lvl
+                      ), &block)
       end
 
       define_method "#{name}?" do
-        return Resources::LOG_LEVELS[self.level] == lvl if self.level.is_a? Numeric
+        return Resources::LOG_LEVELS[self.level] == lvl if level.is_a? Numeric
+
         self.level == lvl
       end
     end
 
     def clear
-      @app = 'default'
-      @level = 'INFO'
+      @app = "default"
+      @log_level = "INFO"
       @env = nil
       @meta = nil
     end
 
-    def loggerExist?
-      if @@client.nil?
-        puts "Logger Not Initialized Yet"
-        close
-      end
-    end
-
-    def <<(msg=nil, opts={})
-      self.log(msg, opts.merge({
-        level: '',
-      }))
+    def <<(msg = nil, opts = {})
+      log(msg, opts.merge(
+                 level: ""
+               ))
     end
 
-    def add(*arg)
-      puts "add not supported in LogDNA logger"
-      return false
+    def add(*_arg)
+      @internal_logger.debug("add not supported in LogDNA logger")
+      false
     end
 
-    def unknown(msg=nil, opts={})
-      self.log(msg, opts.merge({
-        level: 'UNKNOWN',
-      }))
+    def unknown(msg = nil, opts = {})
+      log(msg, opts.merge(
+                 level: "UNKNOWN"
+               ))
     end
 
-    def datetime_format(*arg)
-      puts "datetime_format not supported in LogDNA logger"
-      return false
+    def datetime_format(*_arg)
+      @internal_logger.debug("datetime_format not supported in LogDNA logger")
+      false
     end
 
-
     def close
-      if defined? @@client and !@@client.nil?
-          @@client.exitout()
-      end
-    end
-
-    at_exit do
-      if defined? @@client and !@@client.nil?
-          @@client.exitout()
-      end
+      @client&.exitout
     end
   end
 end

data/lib/logdna/client.rb

@@ -1,47 +1,61 @@
-require 'net/http'
-require 'socket'
-require 'json'
-require 'concurrent'
-require 'thread'
+# frozen_string_literal: true
+
+require "etc"
+require "net/http"
+require "socket"
+require "json"
+require "concurrent"
+require "date"
+require "securerandom"
 
 module Logdna
-  class Client
+  Message = Struct.new(:source, :running_size)
 
+  class Client
     def initialize(request, uri, opts)
       @uri = uri
 
       # NOTE: buffer is in memory
-      @buffer = StringIO.new
-      @messages = []
-      @buffer_over_limit = false
-
-      @side_buffer = StringIO.new
-      @side_messages = []
+      @buffer = []
 
       @lock = Mutex.new
-      @task = nil
 
-      # NOTE: the byte limit only affects the message, not the entire message_hash
-      @actual_byte_limit = opts[:flushbyte] ||= Resources::FLUSH_BYTE_LIMIT
-      @actual_flush_interval = opts[:flushtime] ||= Resources::FLUSH_INTERVAL
+      @flush_interval = opts[:flush_interval] || Resources::FLUSH_INTERVAL
+      @flush_size = opts[:flush_size] || Resources::FLUSH_SIZE
+
+      @request = request
+      @request_size = opts[:request_size] || Resources::REQUEST_SIZE
+
+      @retry_timeout = opts[:retry_timeout] || Resources::RETRY_TIMEOUT
+      @retry_max_jitter = opts[:retry_max_jitter] || Resources::RETRY_MAX_JITTER
+      @retry_max_attempts = opts[:retry_max_attempts] || Resources::RETRY_MAX_ATTEMPTS
 
-      @@request = request
+      @internal_logger = Logger.new($stdout)
+      @internal_logger.level = Logger::DEBUG
+
+      @work_thread_pool = Concurrent::FixedThreadPool.new(Etc.nprocessors)
+      # TODO: Expose an option to configure the maximum concurrent requests
+      # Requires the instance-global request to be resolved first
+      @request_thread_pool = Concurrent::FixedThreadPool.new(Resources::MAX_CONCURRENT_REQUESTS)
+
+      @scheduled_flush = nil
     end
 
-    def encode_message(msg)
-      msg = msg.to_s unless msg.instance_of? String
+    def schedule_flush
+      if @scheduled_flush.nil? || @scheduled_flush.complete?
+        @scheduled_flush = Concurrent::ScheduledTask.execute(@flush_interval) { flush }
+      end
+    end
 
-      begin
-          msg = msg.encode("UTF-8")
-      rescue Encoding::UndefinedConversionError => e
-        # NOTE: should this be raised or handled silently?
-        # raise e
+    def unschedule_flush
+      if !@scheduled_flush.nil?
+        @scheduled_flush.cancel
+        @scheduled_flush = nil
       end
-      msg
     end
 
-    def message_hash(msg, opts={})
-      obj = {
+    def process_message(msg, opts = {})
+      processed_message = {
         line: msg,
         app: opts[:app],
         level: opts[:level],
@@ -49,116 +63,149 @@ module Logdna
         meta: opts[:meta],
         timestamp: Time.now.to_i,
       }
-      obj.delete(:meta) if obj[:meta].nil?
-      obj
+      processed_message.delete(:meta) if processed_message[:meta].nil?
+      processed_message
     end
 
-    def create_flush_task
-      return @task unless @task.nil? or !@task.running?
-
-      t = Concurrent::TimerTask.new(execution_interval: @actual_flush_interval, timeout_interval: Resources::TIMER_OUT) do |task|
-        if @messages.any?
-          # keep running if there are queued messages, but don't flush
-          # because the buffer is being flushed due to being over the limit
-          unless @buffer_over_limit
-            flush()
-          end
-        else
-          # no messages means we can kill the task
-          task.kill
-        end
-      end
-      t.execute
+    def write_to_buffer(msg, opts)
+      Concurrent::Future.execute({ executor: @work_thread_pool }) { write_to_buffer_sync(msg, opts) }
     end
 
-    def check_side_buffer
-      return if @side_buffer.size == 0
-
-      @buffer.write(@side_buffer.string)
-      @side_buffer.truncate(0)
-      queued_side_messages = @side_messages
-      @side_messages = []
-      queued_side_messages.each { |message_hash_obj| @messages.push(message_hash_obj) }
-    end
+    def write_to_buffer_sync(msg, opts)
+      processed_message = process_message(msg, opts)
+      message_size = processed_message.to_s.bytesize
 
+      running_size = @lock.synchronize do
+        running_size = message_size
+        if @buffer.any?
+          running_size += @buffer[-1].running_size
+        end
+        @buffer.push(Message.new(processed_message, running_size))
 
-    # this should always be running synchronously within this thread
-    def buffer(msg, opts)
-      buffer_size = write_to_buffer(msg, opts)
-      unless buffer_size.nil?
-        process_buffer(buffer_size)
+        running_size
       end
-    end
 
-    def write_to_buffer(msg, opts)
-      return if msg.nil?
-      msg = encode_message(msg)
-
-      if @lock.locked?
-        @side_buffer.write(msg)
-        @side_messages.push(message_hash(msg, opts))
-        return
+      if running_size >= @flush_size
+        unschedule_flush
+        flush_sync
+      else
+        schedule_flush
       end
-
-      check_side_buffer
-      buffer_size = @buffer.write(msg)
-      @messages.push(message_hash(msg, opts))
-      buffer_size
     end
 
-    def queue_to_buffer(queue=@queue)
-      next_object = queue.shift
-      write_to_buffer(next_object[:msg], next_object[:opts])
+    ##
+    # Flushes all logs to LogDNA asynchronously
+    def flush(options = {})
+      Concurrent::Future.execute({ executor: @work_thread_pool }) { flush_sync(options) }
     end
 
-    def process_buffer(buffer_size)
-      if buffer_size > @actual_byte_limit
-        @buffer_over_limit = true
-        flush()
-        @buffer_over_limit = false
-      else
-        @task = create_flush_task
+    ##
+    # Flushes all logs to LogDNA synchronously
+    def flush_sync(options = {})
+      slices = @lock.synchronize do
+        # Slice the buffer into chunks that try to be no larger than @request_size. Slice points are found with
+        # a binary search thanks to the structure of @buffer. We are working backwards because it's cheaper to
+        # remove from the tail of an array instead of the head
+        slices = []
+        until @buffer.empty?
+          search_size = @buffer[-1].running_size - @request_size
+          if search_size.negative?
+            search_size = 0
+          end
+
+          slice_index = @buffer.bsearch_index { |message| message.running_size >= search_size }
+          slices.push(@buffer.pop(@buffer.length - slice_index).map(&:source))
+        end
+        slices
+      end
+
+      # Remember the chunks are in reverse order, this un-reverses them
+      slices.reverse_each do |slice|
+        if options[:block_on_requests]
+          try_request(slice)
+        else
+          Concurrent::Future.execute({ executor: @request_thread_pool }) { try_request(slice) }
+        end
       end
     end
 
-    # this should be running synchronously if @buffer_over_limit i.e. called from self.buffer
-    # else asynchronously through @task
-    def flush()
-      if defined? @@request and !@@request.nil?
-        request_messages = []
-        @lock.synchronize do
-          request_messages = @messages
-          @buffer.truncate(0)
-          @messages = []
+    def try_request(slice)
+      body = {
+        e: "ls",
+        ls: slice
+      }.to_json
+
+      flush_id = "#{SecureRandom.uuid} [#{slice.length} lines]"
+      error_header = "Flush {#{flush_id}} failed."
+      tries = 0
+      loop do
+        tries += 1
+
+        if tries > @retry_max_attempts
+          @internal_logger.debug("Flush {#{flush_id}} exceeded 3 tries. Discarding flush buffer")
+          break
         end
-        return if request_messages.empty?
 
-        real = {
-          e: 'ls',
-          ls: request_messages,
-        }.to_json
+        if send_request(body, error_header)
+          break
+        end
 
-        @@request.body = real
-        @response = Net::HTTP.start(@uri.hostname, @uri.port, use_ssl: @uri.scheme == 'https') do |http|
-          http.request(@@request)
+        sleep(@retry_timeout * (1 << (tries - 1)) + rand(@retry_max_jitter))
+      end
+    end
+
+    def send_request(body, error_header)
+      # TODO: Remove instance-global request object
+      @request.body = body
+      begin
+        response = Net::HTTP.start(
+          @uri.hostname,
+          @uri.port,
+          use_ssl: @uri.scheme == "https"
+        ) do |http|
+          http.request(@request)
         end
 
-        # don't kill @task if this was executed from self.buffer
-        # don't kill @task if there are queued messages
-        unless @buffer_over_limit || @messages.any? || @task.nil?
-          @task.shutdown
-          @task.kill
+        code = response.code.to_i
+        if [401, 403].include?(code)
+          @internal_logger.debug("#{error_header} Please provide a valid ingestion key. Discarding flush buffer")
+          return true
+        elsif [408, 500, 504].include?(code)
+          # These codes might indicate a temporary ingester issue
+          @internal_logger.debug("#{error_header} The request failed #{response}. Retrying")
+        elsif code == 200
+          return true
+        else
+          @internal_logger.debug("#{error_header} The request failed #{response}. Discarding flush buffer")
+          return true
         end
+      rescue SocketError
+        @internal_logger.debug("#{error_header} Network connectivity issue. Retrying")
+      rescue Errno::ECONNREFUSED => e
+        @internal_logger.debug("#{error_header} The server is down. #{e.message}. Retrying")
+      rescue Timeout::Error => e
+        @internal_logger.debug("#{error_header} Timeout error occurred. #{e.message}. Retrying")
       end
+
+      false
     end
 
-    def exitout()
-      check_side_buffer
-      if @messages.any?
-        flush()
+    def exitout
+      unschedule_flush
+      @work_thread_pool.shutdown
+      if !@work_thread_pool.wait_for_termination(1)
+        @internal_logger.warn("Work thread pool unable to shutdown gracefully. Logs potentially dropped")
+      end
+      @request_thread_pool.shutdown
+      if !@request_thread_pool.wait_for_termination(5)
+        @internal_logger.warn("Request thread pool unable to shutdown gracefully. Logs potentially dropped")
+      end
+
+      if @buffer.any?
+        @internal_logger.debug("Exiting LogDNA logger: Logging remaining messages")
+        flush_sync({ block_on_requests: true })
+        @internal_logger.debug("Finished flushing logs to LogDNA")
       end
-      puts "Exiting LogDNA logger: Logging remaining messages"
-      return
     end
   end
 end

data/lib/logdna/resources.rb

@@ -1,15 +1,21 @@
+# frozen_string_literal: true
+
 module Resources
-  LOG_LEVELS = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL', 'TRACE'].freeze
-  DEFAULT_REQUEST_HEADER = { 'Content-Type' => 'application/json; charset=UTF-8' }.freeze
-  DEFAULT_REQUEST_TIMEOUT = 180000
-  MS_IN_A_DAY = 86400000
-  MAX_REQUEST_TIMEOUT = 300000
-  MAX_LINE_LENGTH = 32000
+  LOG_LEVELS = %w[DEBUG INFO WARN ERROR FATAL TRACE].freeze
+  DEFAULT_REQUEST_HEADER = { "Content-Type" => "application/json; charset=UTF-8" }.freeze
+  DEFAULT_REQUEST_TIMEOUT = 180_000
+  MS_IN_A_DAY = 86_400_000
+  MAX_REQUEST_TIMEOUT = 300_000
+  MAX_LINE_LENGTH = 32_000
   MAX_INPUT_LENGTH = 80
+  RETRY_TIMEOUT = 0.25
+  RETRY_MAX_ATTEMPTS = 3
+  RETRY_MAX_JITTER = 0.5
   FLUSH_INTERVAL = 0.25
-  TIMER_OUT = 15
-  FLUSH_BYTE_LIMIT = 500000
-  ENDPOINT = 'https://logs.logdna.com/logs/ingest'.freeze
-  MAC_ADDR_CHECK = /^([0-9a-fA-F][0-9a-fA-F]:){5}([0-9a-fA-F][0-9a-fA-F])$/
-  IP_ADDR_CHECK = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/
+  FLUSH_SIZE = 2 * 1_024 * 1_024
+  REQUEST_SIZE = 2 * 1_024 * 1_024
+  ENDPOINT = "https://logs.logdna.com/logs/ingest"
+  MAC_ADDR_CHECK = /^([0-9a-fA-F][0-9a-fA-F]:){5}([0-9a-fA-F][0-9a-fA-F])$/.freeze
+  IP_ADDR_CHECK = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.freeze
+  MAX_CONCURRENT_REQUESTS = 1
 end

data/lib/logdna/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LogDNA
-  VERSION = '1.2.0'.freeze
+  VERSION = "1.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logdna
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.5.0
 platform: ruby
 authors:
-- Gun Woo Choi, Derek Zhou
+- Gun Woo Choi, Derek Zhou, Vilya Levitskiy, Muaz Siddiqui
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-01 00:00:00.000000000 Z
+date: 2021-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: require_all
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -53,80 +39,45 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.13'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.13'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.5'
-- !ruby/object:Gem::Dependency
-  name: rspec
+  name: require_all
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
-  type: :development
+        version: '1.4'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '0.78'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '0.78'
 description: 
-email: support@logdna.com
+email: apps+rubygems@logdna.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".ruby-version"
-- Gemfile
-- LICENSE.txt
+- LICENSE
 - README.md
-- Rakefile
 - lib/logdna.rb
 - lib/logdna/client.rb
 - lib/logdna/resources.rb
 - lib/logdna/version.rb
-- logdna.gemspec
-- test.rb
 homepage: https://github.com/logdna/ruby
 licenses:
 - MIT
@@ -139,15 +90,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: LogDNA Ruby logger

data/.gitignore

@@ -1,11 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-*.gem
-.DS_Store

data/.rspec

@@ -1,2 +0,0 @@
---format documentation
---color

data/.ruby-version

@@ -1 +0,0 @@
-2.2.0

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in logdna_ruby.gemspec
-gemspec

data/Rakefile

@@ -1,6 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec

data/logdna.gemspec

@@ -1,32 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'logdna/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'logdna'
-  spec.version       = LogDNA::VERSION
-  spec.authors       = 'Gun Woo Choi, Derek Zhou'
-  spec.email         = 'support@logdna.com'
-
-  spec.summary       = 'LogDNA Ruby logger'
-  spec.homepage      = 'https://github.com/logdna/ruby'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-
-  spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
-  spec.add_runtime_dependency 'require_all', '~> 1.4'
-  spec.add_runtime_dependency 'json', '~> 2.0'
-
-  spec.add_development_dependency 'bundler', '~> 1.13'
-  spec.add_development_dependency 'rake', '~> 10.5'
-  spec.add_development_dependency 'rspec', '~> 3.5'
-  spec.add_development_dependency 'webmock', '~> 2.3'
-end

data/test.rb

@@ -1,69 +0,0 @@
-require 'require_all'
-require_all 'lib'
-
-
-options = {hostname: "new_ruby", meta:{:once => {:first => "nested1", :another => "nested2"}}}
-
-
-logger1 = Logdna::Ruby.new('Your API Key', options)
-
-logger1.log('**************** This is the start of test ****************')
-logger1.env = 'STAGING'
-logger1.app = 'HELLO'
-logger1.warn('Warn message with Staging and Hello')
-logger1.clear
-logger1.log('Is everything back to normal?')
-
-
-logger1.log('Testing env app name change using log')
-logger1.env = 'PRODUCTION'
-logger1.app = 'CHANGED'
-logger1.log('This should be stage = PRODUCTION and appname = CHANGED')
-logger1.log('Testing env app name change using other messages')
-
-
-logger1.error('This is error message with env = DEVELOPMENT and appname = NIHAO', {:env => 'DEVELOPMENT', :app => 'NIHAO'})
-logger1.log('Should not stay as DEVELOPMENT and NIHAO')
-logger1.env = 'DEVELOPMENT'
-logger1.app = 'NIHAO'
-logger1.log('Now should be DEVELOPMENT and NIHAO')
-logger1.log('Logging metadata in trace level', {:meta => {:once => {:first => "nested1", :another => "nested2"}}, :level => "TRACE"})
-
-
-logger1.level = Logger::DEBUG
-logger1.log('This is debug message')
-logger1.add('this should not be supported')
-logger1.fatal('Does this continue as fatal?')
-logger1.log('This should be debug')
-logger1.level = Logger::WARN
-logger1.log('**************** This is the end of test ****************')
-
-
-=begin
-logger1.level = Logger::WARN
-logger1.log('This should be warn')
-logger1.trace('This should be trace')
-logger1.log('Again warn level')
-
-logger1.log('Warn level log1')
-logger1.info('Info level log1')
-logger1.level = Logger::DEBUG
-logger1.log('DEBUG log1')
-
-logger1.app = 'NEW APP NAME'
-logger1.env = 'Staging'
-logger1.level = 'INFO'
-
-
-
-logger1.level = 'INFO'
-logger1.level == Logger::INFO
-
-
-logger1.log('are changes all updated')
-=end
-sleep 3
-
-
-
-