unilogger 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+log/
+pkg/*

data/Gemfile

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

data/README

@@ -0,0 +1,49 @@
+Unified logger that writes to a log file.
+Could eventually also write to a redis queue, mongo collection, and hoptoad.
+
+Unilogger is composed at runtime of a Logger instance which delegates log messages to a set of emitters.
+The emitters do the actual work of sending log messages to stderr, a file, redis, or elsewhere.
+
+Unilogger will initialize itself from a logger.yml or logger.yml.erb configuration file, if present.
+
+The configuration file should contain an entry named after the current environment, e.g.
+"development", "test", "production", etc.
+
+Logger options
+--------------
+level:      overall level; messages of severity less than this will not be emitted regardless of the level of the emitter.
+emitters:   a list of emitters.
+
+Standard (log file) emitter
+---------------------------
+kind:       LogFileEmitter
+logdev:     "stderr", "stdout", or a filename
+shift_age:  "daily", "weekly" or "monthly" to rotate based on the calendar
+            if rotating based on file size, number of files to keep
+            default 7
+shift_size: a file size, to rotate based on the file size
+            default 1048576
+
+Redis emitter
+-------------
+kind:       RedisEmitter
+
+
+Example logger.yml
+------------------
+stderr:         &stderr
+  logger:
+    logdev:     stderr
+
+standard:       &standard
+  logger:
+    logdev:     "<%= ENV["RACK_ENV"] || "development" %>.log"
+    shift_age:  daily
+
+development:
+  level:        0
+  emitters:     [ *standard ]
+
+test:
+  level:        1
+  emitters:     [ *stderr ]

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/unilogger.rb

@@ -0,0 +1,13 @@
+require "unilogger/builder"
+require "unilogger/log_file_emitter"
+require "unilogger/logger"
+
+module Unilogger
+  
+  class << self
+    def build( options )
+      Builder.build( options )
+    end
+  end
+  
+end

data/lib/unilogger/builder.rb

@@ -0,0 +1,63 @@
+require "erb"
+require "unilogger/logger"
+require "yaml"
+
+module Unilogger
+  class Builder
+    
+    class << self
+      
+      # options must include
+      # env => "development", "test", "production", etc.
+      # root => parent of config and log directories
+      def build( options )
+        env  = options[:env] || ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
+        root = options[:root]
+        
+        if File.exist?( yml = "#{root}/config/logger.yml" ) then
+          cfg = YAML.load(IO.read( yml )) [env]
+        elsif File.exist?( yml = "#{root}/config/logger.yml.erb" )
+          cfg = YAML.load( (ERB.new( IO.read( yml ) ).result) ) [env]
+        else
+          cfg = { "level" => "debug", "emitters" => [ { "logger" => { "logdev" => "stderr" } } ] }
+        end
+        
+        Unilogger::Builder.new( cfg ).logger
+      end
+      
+      def as_level( level, default_level = ::Logger::Severity::INFO )
+        return default_level if level.nil? || level.size == 0
+        return level if level.kind_of?(Integer)
+        ::Logger::Severity.const_get( level.to_s.upcase )
+      end
+      
+      def as_factory( kind )
+        kind = "LogFileEmitter" if kind =~ /^logger$/i
+        factory = Unilogger.const_get(kind) rescue Object.const_get(kind) rescue nil
+        raise "unknown kind of emitter (#{kind})" if ! factory
+        return factory
+      end
+      
+    end # class
+    
+    def initialize( configuration )
+      @configuration = configuration
+    end
+    
+    def logger
+      # accept debug...fatal, 0...4, default info
+      level = self.class.as_level( @configuration["level"] )
+      
+      # emitters
+      emitters = @configuration["emitters"].map do |options|
+        options = options.first
+        kind    = options.first
+        factory = self.class.as_factory( kind )
+        factory.build( options.last )
+      end
+      
+      Logger.new( level, emitters )
+    end
+    
+  end
+end

data/lib/unilogger/log_file_emitter.rb

@@ -0,0 +1,41 @@
+require "logger"
+
+module Unilogger
+  
+  class LogFileEmitter
+    
+    class << self
+      def build( options )
+        logdev = options.delete("logdev")
+        case logdev
+        when nil, /stderr/i
+          new( STDERR, :logdev => "STDERR" )
+        when /stdout/i
+          new( STDOUT, :logdev => "STDOUT" )
+        else
+          new( logdev, options.merge( :logdev => logdev ) )
+        end
+      end
+    end
+    
+    # options includes a JSON representation of logdev
+    def initialize( logdev, options = {} )
+      @options = options
+      @logdev  = ::Logger::LogDevice.new( logdev, options )
+    end
+    
+    def emit( details, message, options )
+      if options && options.size > 0 then
+        options = options.map { |k,v| [k, v.to_json].join(":") }.join(",")
+        message = "#{message}; #{options}"
+      end
+      @logdev.write "#{details[:time].to_i} [#{details[:pid]}:#{details[:fiber]}] #{details[:pri_sym]} #{message}\n"
+    end
+    
+    def as_json
+      { :log_file => @options }
+    end
+    
+  end # LogFileEmitter
+
+end # Unilogger

data/lib/unilogger/logger.rb

@@ -0,0 +1,92 @@
+require "fiber" unless RUBY_VERSION =~ /^1\.8/
+require "json"
+require "logger"
+
+module Unilogger
+  
+  # Adds pid and timestamp to each log entry.
+  # Implements IO API (<<) which is equivalent to info()
+  # Implements Logger API (debug, info, warn, error, fatal)
+  class Logger
+    
+    include ::Logger::Severity
+    attr :level, true
+    attr :emitters
+    
+    def initialize( level = DEBUG, emitters = [] )
+      @level    = level
+      @emitters = emitters.dup
+    end
+    
+    def emit( details, message, options )
+      @emitters.each { |e| e.emit( details, message, options ) }
+    end
+    
+    def <<( message )
+      details = { :pri_sym => :INFO, :pri_num => Logger::Severity::INFO, :pid => Process.pid, :time => Time.now }
+      self.emit( details, message, nil )
+    end
+    
+    # level methods may take 0..2 arguments, or a block parameter
+    # argument 1 or the block is stringified as the primary message
+    # argument 2 is a set of named parameters (e.g. a hash)
+    ::Logger::Severity.constants.each do |const|
+      
+      # const e.g. INFO; label e.g. info; priority e.g. 1
+      label = const.to_s.downcase.to_sym
+      priority = ::Logger::Severity.const_get(const)
+      
+      # def info( message, options = {}, &block ) ...
+      define_method( label ) do |*args,&block|
+        raise ArgumentError if args.size > 2
+        if @level <= priority then
+          details = { :pri_sym => const, :pri_num => priority, :pid => Process.pid, :time => Time.now, :fiber => 0 } if RUBY_VERSION =~ /^1\.8/
+          details = { :pri_sym => const, :pri_num => priority, :pid => Process.pid, :time => Time.now, :fiber => Fiber.current.object_id } unless RUBY_VERSION =~ /^1\.8/
+          case args.size
+          when 0
+            message = block.call if block
+            options = nil
+          when 1
+            message = args.first
+            options = nil
+          when 2
+            message = args.first
+            options = args.last
+          end
+          self.emit( details, message.to_s, options )
+        end
+        @level <= priority
+      end # info()
+      
+      # def info?
+      define_method( "#{label}?".to_sym ) do
+        @level <= priority
+      end # info?
+      
+    end # each
+    
+    def as_json
+      { :level => @level, :emitters => as_json_helper(@emitters) }
+    end
+    
+    def as_json_helper( it )
+      if it.nil? then
+        it
+      elsif it.respond_to?(:as_json) then
+        it.as_json
+      elsif it.kind_of?(Hash) then
+        it.inject({}) { |a,i| a[i.first] = as_json_helper(i.last); a }
+      elsif it.kind_of?(Array) || it.kind_of?(Enumerable)
+        it.map { |i| as_json_helper(i) }
+      else
+        it
+      end
+    end
+    
+    def to_json
+      as_json.to_json
+    end
+    
+  end # Logger
+
+end # Unilogger

data/lib/unilogger/mongo_emitter.rb

@@ -0,0 +1,18 @@
+require "logger"
+require "mongo"
+
+module Unilogger
+  
+  class MongoEmitter
+    
+    class << self
+      def build( options )
+      end
+    end
+    
+    def emit( details, message, options )
+    end
+    
+  end # MongoEmitter
+
+end # Unilogger

data/lib/unilogger/redis_emitter.rb

@@ -0,0 +1,19 @@
+require "logger"
+require "redis"
+require "redis/namespace"
+
+module Unilogger
+  
+  class RedisEmitter
+    
+    class << self
+      def build( options )
+      end
+    end
+    
+    def emit( details, message, options )
+    end
+    
+  end # RedisEmitter
+
+end # Unilogger

data/lib/unilogger/version.rb

@@ -0,0 +1,3 @@
+module Unilogger
+  VERSION = "0.0.1"
+end

data/test/logger.yml.erb

@@ -0,0 +1,28 @@
+stderr:         &stderr
+  LogFileEmitter:
+    logdev:     stderr
+
+standard:       &standard
+  LogFileEmitter:
+    logdev:     "./log/<%= ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development" %>.log"
+    shift_age:  daily
+
+development:
+  level:        debug
+  emitters:     [ *standard ]
+
+test:
+  level:        info
+  emitters:     [ *stderr ]
+
+beta:
+  level:        info
+  emitters:     [ *standard ]
+
+staging:
+  level:        info
+  emitters:     [ *standard ]
+
+production:
+  level:        info
+  emitters:     [ *standard ]

data/test/test.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+root = File.expand_path( "../..", __FILE__ )
+$: << root + "/lib"
+require "unilogger"
+
+logger = Unilogger::Builder.build :root => root
+puts logger.to_json
+
+logger.debug "Starting."
+logger.info  "started", :root => root
+logger.warn  "nothing to do"
+logger.error "end of file"
+logger.fatal "exiting"

data/unilogger.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "unilogger/version"
+
+Gem::Specification.new do |s|
+  s.name        = "unilogger"
+  s.version     = Unilogger::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Mark Lanett"]
+  s.email       = ["mark.lanett@gmail.com"]
+  s.homepage    = ""
+  s.summary     = "Unified logger that writes to a log file, redis queue, mongo collection, and hoptoad."
+  
+  s.rubyforge_project = "unilogger"
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency "json"
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: unilogger
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mark Lanett
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-04 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: 
+- mark.lanett@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- lib/unilogger.rb
+- lib/unilogger/builder.rb
+- lib/unilogger/log_file_emitter.rb
+- lib/unilogger/logger.rb
+- lib/unilogger/mongo_emitter.rb
+- lib/unilogger/redis_emitter.rb
+- lib/unilogger/version.rb
+- test/logger.yml.erb
+- test/test.rb
+- unilogger.gemspec
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: unilogger
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Unified logger that writes to a log file, redis queue, mongo collection, and hoptoad.
+test_files: 
+- test/logger.yml.erb
+- test/test.rb