logbert 0.6.19 → 1.0.0

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: b275b578f275a5128b532985399a1fe462f9378e
-  data.tar.gz: dfa06f7f9fa72e013f4ad2a7497f11eff15d9a76
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MWZhNDk3MmU1ZjgxMDViZjhhZjE5NTZhNDVhYjJlY2RmZjljOTdkYw==
+  data.tar.gz: !binary |-
+    ZmQwMjJiYjMxNjk4OGYxMTg3OGIzZTkzYzRiYTQ3NmFlN2I2ZWMxNQ==
 SHA512:
-  metadata.gz: b762386179f3eeca54471dc85f0454fd35135cbae10a37c4d2c457c830a74117c77022d5a327ece3a1ff812ec33cd827adff2ddd8be378c89e3c9efb486a2590
-  data.tar.gz: cbb567dd894426805334729352422c433c3184d4bddfa5ea9e73ec90c3589946cdb9b283be4fbd7a2ae8227056920765a35def1723f127b1ae3d306f1542dcfc
+  metadata.gz: !binary |-
+    ZjEwNTNmYWU2ODNjMGI2NDA4ZjEzOTA2YzhkMGQyNmZjMDRlNzJiMWY2NDYw
+    ZGFlNTMzZTIxZDZmYzg0NjkxY2EzZTc3NzllMjFmOWVlYjc5Y2IwNjFjYTRi
+    MWE4MmY4NGRmOTM3Zjc3YTE5NTdhNDBhZDM5N2VmZjg1NGEwYzE=
+  data.tar.gz: !binary |-
+    MjE4NmE1ZTMzY2U2MDBkNWFhMzY0YTAzYTY0YTM4Y2MzYTU2MDMxZDU3MDQw
+    MDgzNGI5ZTE4NzBiY2FkMjdiNzM2ZjE4YjAwODdkYThjMGI0NWJjNmJlMjgy
+    OTQwNWU3NzIyZjZjNTNmN2U0OGVjMmUxZDdlMmYwNDc5OWYyOTI=

data/lib/logbert/consumers.rb

@@ -0,0 +1 @@
+require 'logbert/consumers/redis_consumer'

data/lib/logbert/consumers/redis_consumer.rb

@@ -0,0 +1,32 @@
+require 'redis'
+require 'logbert/message'
+require 'logbert/handlers'
+
+module Logbert
+  module Consumers
+
+    class RedisConsumer
+
+      attr_accessor :redis, :key, :handlers
+
+      def initialize(redis_connection, key, options = {})
+        @redis    = redis_connection
+        @key      = key
+        @handlers = options.fetch(:handlers, [])
+      end
+
+      def work
+        # Blocking loop to read serialized messages of the redis queue
+        loop do
+          msg = redis.brpop(key) # blocking list pop primitive
+          @handlers.each do |h|
+            m = Message.from_json(msg)
+            h.handle_message(m)
+          end
+        end
+      end
+
+    end # class RedisConsumer
+
+  end # module Consumers
+end # module Logbert

data/lib/logbert/handlers.rb

@@ -1,4 +1,5 @@
 
 require 'logbert/handlers/stream_handler'
-require 'logbert/handlers/time_rotator'
-require 'logbert/handlers/array_handler'
+require 'logbert/handlers/log_rotator'
+require 'logbert/handlers/array_handler'
+require 'logbert/handlers/redis_handler'

data/lib/logbert/handlers/log_rotator.rb

@@ -0,0 +1,173 @@
+require 'fileutils'
+require 'logbert/handlers/base_handler'
+require 'lockfile'
+require 'zlib'
+
+module Logbert
+  module Handlers
+
+    ###########################################################################
+    #                          Default Time Formatter                         #
+    ###########################################################################
+    class LocaltimeFormatter
+
+      attr_accessor :format
+
+      def initialize(format = "%Y-%m-%d-%H%M")
+        @format = format
+      end
+
+      def format(time)
+        time.strftime(@format)
+      end
+
+    end # class LocaltimeFormatter
+
+    ###########################################################################
+    # This class is a custom Handler responsible for rotating logs. This      #
+    # means that it will periodically:                                        #
+    # * Close the current log file and rename it.                             #
+    # * Begin writing future log messages to a new file.                      #
+    # * Delete the oldest log files to free up space                          #
+    # Time-based log rotation                                                 #
+    ###########################################################################
+    class LogRotator < Logbert::Handlers::BaseHandler
+
+      attr_reader :file_handle, :timestamp_formatter, :interval
+      attr_reader :expiration_timestamp, :max_backups
+      attr_reader :path
+
+      def initialize(path, options = {})
+        @path                = path
+        @max_backups         = options.fetch(:max_backups, nil)
+        @timestamp_formatter = options.fetch(:timestamp_formatter, LocaltimeFormatter.new)
+        @interval            = options.fetch(:interval, (24 * 60 * 60))
+      end
+
+      def attached?
+        return !file_handle.nil?
+      end
+
+      def lock_file_name_for(log_path)
+        return "#{log_path}.lock"
+      end
+
+      def rotation_required?
+        return Time.now > @expiration_timestamp
+      end
+
+      def already_rotated?
+        return File.ctime(@path) > @expiration_timestamp
+      end
+
+      def attach_to_logfile!
+        lock do
+          dirname               = File.dirname(File.absolute_path(@path))
+          FileUtils.mkdir_p dirname unless File.exists? dirname
+          @file_handle          = File.open(@path, 'a')
+          creation_timestamp    = File.ctime(@path)
+          @expiration_timestamp = compute_expiration_timestamp_from(creation_timestamp)
+        end
+      end
+
+      def emit(output)
+        attach_to_logfile! unless attached?
+        rotate_logs! if rotation_required?
+        @file_handle.puts output
+        @file_handle.flush
+      end
+
+      def compute_expiration_timestamp_from(timestamp)
+        return timestamp + @interval
+      end
+
+      def lock(&block)
+        Lockfile.new(lock_file_name_for(@path)) do
+          block.call
+        end
+      end
+
+      def rotate_logs!
+        performed_swap = false
+
+        lock do
+          # Double-check that the file wasn't already rotated
+          unless already_rotated?
+            performed_swap = true
+
+            # Close the old log
+            if @file_handle and not @file_handle.closed?
+              @file_handle.close
+            end
+
+            # Rename the old log
+            if File.exists? @path
+              FileUtils.mv @path, archive_destination
+            end
+
+          end
+        end # Lockfile lock
+
+        attach_to_logfile!
+
+        # Post-Processing logic if the rotation was performed
+        post_process if performed_swap
+      end
+
+      # This will essentially perform at most two things:
+      # 1.) Compress older log files
+      # 2.) Delete, if any, old log files based upon max_backups
+      def post_process
+        compress_backups
+        delete_backups
+      end
+
+      def compress_backups
+        # Compress older log files (unless already compressed)
+        get_old_logs.each do |log|
+          unless File.extname(log) == ".gz"
+            # Compress the file
+            gzip(log)
+            # Delete the actual log file
+            File.delete(log)
+          end
+        end
+      end
+
+      def delete_backups
+        # Delete, if any, old log files based upon max_backups
+        unless @max_backups.nil?
+          # Grab all the logs.  Sort from newest to oldest
+          old_logs = get_old_logs.sort_by {|f| File.ctime(f)}.reverse[@max_backups..-1]
+
+          # If we have more than max_backups logs, then delete the extras
+          old_logs.each {|f| File.delete(f)} if old_logs
+        end
+      end
+
+      def gzip(file)
+        Zlib::GzipWriter.open("#{file}.gz") do |gz|
+          gz.mtime = File.mtime(file)
+          gz.orig_name = file
+          gz.write IO.binread(file)
+          gz.close
+        end
+      end
+
+      def get_old_logs
+        absolute_dir = File.dirname(File.absolute_path(@path))
+        older_files = Dir[File.join(absolute_dir, "#{@path}.backup.*")]
+        return older_files
+      end
+
+      def archive_destination
+        timestamp = @timestamp_formatter.format(File.ctime(@path))
+        dest = "#{@path}.backup.#{timestamp}"
+        return dest
+      end
+
+      private :archive_destination, :post_process
+    end # class LogRotator
+
+  end # module Handlers
+end # module Logbert

data/lib/logbert/handlers/redis_handler.rb

@@ -0,0 +1,23 @@
+require 'logbert/handlers/base_handler'
+require 'redis'
+
+module Logbert
+  module Handlers
+
+    class RedisQueueHandler < Logbert::Handlers::BaseHandler
+
+      attr_accessor :redis, :key
+
+      def initialize(redis_connection, key, options = {})
+        @redis = redis_connection
+        @key   = key
+      end
+
+      def publish(message)
+        redis.lpush(@key, message.to_json)
+      end
+
+    end # class RedisQueueHandler
+
+  end # module Handlers
+end # module Logbert

data/lib/logbert/logger.rb

@@ -1,13 +1,14 @@
 
 require 'logbert/message'
 require 'logbert/handlers'
+require 'logbert/consumers'
 
 module Logbert
-  
+
   class Logger
-    
+
     attr_reader :factory, :level_manager, :name, :handlers
-    
+
     def initialize(factory, level_manager, name)
       @factory       = factory
       @level_manager = level_manager
@@ -15,15 +16,15 @@ module Logbert
       @name     = name.dup.freeze
       @handlers = []
     end
-    
+
     def level_inherited?
       !@level
     end
-    
+
     def level
       @level || self.parent.level
     end
-    
+
     def level=(x)
       @level = @level_manager[x]
     end
@@ -40,10 +41,10 @@ module Logbert
     def root
       self.factory.root
     end
-    
+
     def log(level, *args, &block)
       content, options = self.prepare_message_args(*args, &block)
-      
+
       exception = options[:exc_info]
       if exception
         # If the user passed in an exception, then use that one.
@@ -55,15 +56,15 @@ module Logbert
       message = Logbert::Message.create(self, @level_manager[level], exception, options, content, &block)
       handle_message(message)
     end
-    
-    
+
+
     def to_s
       @name
     end
-    
+
     protected
-    
-    
+
+
     # This method will be unnecessary once we upgrade to Ruby 2.x
     def prepare_message_args(*args, &block)
       if args.size == 0
@@ -93,4 +94,3 @@ module Logbert
   end
 
 end
-

data/lib/logbert/message.rb

@@ -1,9 +1,8 @@
 
 module Logbert
-  
   class Message
     attr_reader :logger, :level, :time, :pid, :exception, :options, :content_proc
-    
+
     def initialize(logger, level, time, pid, exception, options, content = nil, &content_proc)
       @logger       = logger
       @level        = level
@@ -11,13 +10,44 @@ module Logbert
       @pid          = pid
       @exception    = exception
       @options      = options
-      
+
       @content      = content
       @content_proc = content_proc
     end
 
     def self.create(logger, level, exception, options, content = nil, &content_proc)
-      Message.new logger, level, Time.now, Process.pid, exception, options, content, &content_proc
+      Message.new logger, level, Time.now, Process.pid, Message.convert_exception(exception), options, content, &content_proc
+    end
+
+    def self.from_json(json_msg)
+      l = Level.new(json_msg[:level_name], json_msg[:level_value])
+      # note: the exception key contains a hash-level representation of an exception
+      Message.create(json_msg[:logger], l, json_msg[:exception], json_msg[:options], json_msg[:content], json_msg[:content_proc])
+    end
+
+    def to_json
+      return {
+        logger:       @logger.to_s,
+        level:        {level_value: @level.value, level_name: @level.name},
+        time:         @time.to_s,
+        pid:          @pid,
+        exception:    @exception,
+        options:      @options,
+        content:      self.content,
+        content_proc: nil
+      }
+    end
+
+    def self.convert_exception(exc)
+      if exc.is_a? Exception
+        return {
+          exc_class:     exc.exception.class,
+          exc_message:   exc.exception.message,
+          exc_backtrace: exc.exception.backtrace
+        }
+      else
+        return exc
+      end
     end
 
     # Returns the content.  If the content has not been created yet,
@@ -32,8 +62,5 @@ module Logbert
       end
     end
 
-  end
-  
-  
-end
-
+  end  # class Message
+end # module Logbert

data/lib/logbert/naming.rb

@@ -1,6 +1,6 @@
 
 module Logbert
-  
+
   NameSeparator = "/"
 
   def self.split_name(name)
@@ -16,5 +16,3 @@ module Logbert
   end
 
 end
-
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logbert
 version: !ruby/object:Gem::Version
-  version: 0.6.19
+  version: 1.0.0
 platform: ruby
 authors:
 - Brian Lauber
@@ -9,18 +9,49 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2014-04-29 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lockfile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.3
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
 description: Change your logging behaviors without mucking with your code!
 email: constructible.truth@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/logbert/consumers/redis_consumer.rb
+- lib/logbert/consumers.rb
 - lib/logbert/formatters.rb
 - lib/logbert/handlers/array_handler.rb
 - lib/logbert/handlers/base_handler.rb
+- lib/logbert/handlers/log_rotator.rb
+- lib/logbert/handlers/redis_handler.rb
 - lib/logbert/handlers/stream_handler.rb
-- lib/logbert/handlers/time_rotator.rb
 - lib/logbert/handlers.rb
 - lib/logbert/levels.rb
 - lib/logbert/logger.rb
@@ -38,17 +69,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: Logging for winners.

data/lib/logbert/handlers/time_rotator.rb

@@ -1,80 +0,0 @@
-
-require 'fileutils'
-require 'logbert/handlers/base_handler'
-
-module Logbert
-  
-  module Handlers
-    
-    class LocaltimeFormatter
-      
-      attr_accessor :format
-
-      def initialize(format = "%Y-%m-%d-%H%M")
-        @format = format
-      end
-
-      def format(time)
-        time.strftime(@format)
-      end
-    end
-
-    
-    class TimeRotator < Logbert::Handlers::BaseHandler
-      
-      
-      attr_reader :path, :stream, :timestamp_formatter
-      attr_reader :interval, :expiration_time
-      
-      def initialize(path, options = {})
-        @path                = path
-        @timestamp_formatter = options[:timestamp_formatter] || LocaltimeFormatter.new
-        @interval            = options.fetch(:iterval, 24 * 60 * 60)
-        
-        rotate_log!
-      end
-      
-      
-      def rotation_needed?
-        Time.now > @expiration_time
-      end
-      
-      
-      def rotate_log!
-        if @stream and not @stream.closed?
-          @stream.close
-        end
-        
-        if File.exists? @path
-          FileUtils.mv @path, archive_destination
-        end
-        
-        @stream = File.open(@path, "ab")
-
-        @expiration_time = Time.now + @interval
-      end
-
-      
-      
-      def emit(output)
-        rotate_log! if rotation_needed?
-        @stream.puts output
-        @stream.flush
-      end
-      
-      
-      private
-      
-      
-      def archive_destination
-        timestamp = @timestamp_formatter.format(File.ctime(@path))
-        dest = "#{path}.#{timestamp}"
-        return dest
-      end
-      
-    end
-    
-    
-  end
-  
-end