gray_logger 0.9.4 → 0.9.5

data/lib/gray_logger.rb

@@ -2,12 +2,12 @@ require 'singleton'
 require 'gelf'
 
 require 'gray_logger/support'
+require 'gray_logger/bucket'
 require 'gray_logger/message'
-require 'gray_logger/message_store'
-require 'gray_logger/middleware'
+require 'gray_logger/logger'
+require 'gray_logger/rack'
 require 'gray_logger/helper_methods'
 
-
 if defined?(Rails)
   require 'gray_logger/rails_modules'
   require 'gray_logger/railtie' if defined?(Rails::Railtie)

data/lib/gray_logger/bucket.rb

@@ -0,0 +1,35 @@
+module GrayLogger
+
+  class Bucket < Hash
+    alias_method :<<, :merge!
+
+    def to_message(name=nil)
+      self[:gray_logger_bucket] = name if name
+      GrayLogger::Message.new(self)
+    end
+
+    def append_to(field_name, value)
+      self[field_name.to_sym] ||= ""
+      self[field_name.to_sym] << "#{value}\n"
+    end
+
+    protected
+    def method_missing(method_name, args, &block)
+      if method_name.to_s.end_with?("=")
+
+        # def method_name=(value)
+        #   self[:method_name] = value
+        # end
+        instance_eval <<-EOMEVAL
+          def #{method_name}(value)
+            self[:#{method_name.to_s.chop}] = value
+          end
+        EOMEVAL
+
+        send(method_name, args)
+      end
+    end
+
+  end
+
+end

data/lib/gray_logger/helper_methods.rb

@@ -1,11 +1,7 @@
 module GrayLogger
   module HelperMethods
     def gray_logger
-      if Rails.version.to_i >= 3
-        env["rack.gray_logger.message_store"]
-      else
-        request.env["rack.gray_logger.message_store"]
-      end
+      Rack::GrayLogger.proxy.gray_logger
     end
     protected :gray_logger
   end

data/lib/gray_logger/logger.rb

@@ -0,0 +1,62 @@
+module GrayLogger
+
+  class Logger < GELF::Logger
+    include ::GrayLogger::Support
+    attr_reader :buckets
+
+    def initialize(configuration={})
+      defaults = {
+        :size => "WAN",
+        :facility => "facility-not-defined"
+      }
+
+      config = symbolize_keys(configuration)
+      config = defaults.merge(config)
+
+      super(config.delete(:host), config.delete(:port), config.delete(:size), config)
+
+      @buckets = {}
+    end
+
+    # logger.after_request_log << {:my_field => 'field content'}
+    # logger.after_request_log.my_field = 'field content'
+    def after_request_log
+      bucket(:_request)
+    end
+
+    # logger.bucket(:my_bucket) << {:my_field => 'field content'}
+    # logger.bucket(:my_bucket).my_field = 'field content'
+    def bucket(name)
+      @buckets[name.to_sym] ||= GrayLogger::Bucket.new
+    end
+
+    # flush all buckets
+    def flush
+      @buckets.keys.each do |bucket_name|
+        flush_bucket(bucket_name)
+      end
+    end
+
+    # flush a specific bucket
+    def flush_bucket(name)
+      return false if get_bucket(name).nil?
+      message = get_bucket(name).to_message(name)
+      self.notify!(message)
+      @buckets.delete(name.to_sym)
+    end
+
+    def log_exception(exception)
+      if exception
+        after_request_log.short_message = "Error: #{exception.inspect}"
+        after_request_log.exception_backtrace = exception.backtrace.join("\n")
+      end
+    end
+
+    private
+    def get_bucket(name)
+      @buckets[name.to_sym]
+    end
+
+  end
+
+end

data/lib/gray_logger/message.rb

@@ -1,5 +1,4 @@
 module GrayLogger
-
   class Message
     include GrayLogger::Support
 

data/lib/gray_logger/rack.rb

@@ -0,0 +1,100 @@
+module Rack
+  module GrayLogger
+    class Middleware
+      include ::GrayLogger::Support
+
+      attr_accessor :gray_logger
+
+      def initialize(app, options={})
+        @app = app
+
+        configuration = symbolize_keys(options.delete(:configuration))
+        self.gray_logger = ::GrayLogger::Logger.new(configuration)
+
+        ::Rack::GrayLogger.proxy.gray_logger = gray_logger if ::Rack::GrayLogger.proxy
+      end
+
+      def call(env)
+
+        begin
+          status, headers, body = @app.call(env)
+        rescue => e
+          gray_logger.log_exception(e)
+          raise
+        ensure
+          req = Rack::Request.new(env)
+          gray_logger.log_exception(env['rack.exception'])
+          gray_logger.after_request_log.status_code = status.to_i
+          gray_logger.after_request_log.short_message = "Request: #{req.path} (#{status.to_i})" if gray_logger.after_request_log[:short_message].nil?
+          gray_logger.flush
+          [status, headers, body]
+        end
+
+      end
+
+    end
+
+    class Proxy
+      attr_accessor :proxied_logger, :gray_logger
+
+      def initialize(attributes={})
+        self.proxied_logger = attributes[:proxied_logger]
+        self.gray_logger = attributes[:gray_logger]
+      end
+
+      # def debug(*args)
+      #   if proxied_logger.nil?
+      #     super(*args)
+      #   else
+      #     after_request_log.append_to(:log_file, "[debug] #{args[0]}") unless gray_logger.nil?
+      #     proxied_logger.send(:debug, *args)
+      #   end
+      # end
+      GELF::Levels.constants.each do |const|
+        class_eval <<-EOT, __FILE__, __LINE__ + 1
+          def #{const.downcase}(*args)
+            if proxied_logger.nil?
+              gray_logger.send(:#{const.downcase}, *args)
+            else
+              gray_logger.after_request_log.append_to(:log_file, "[#{const.downcase}] \#{args[0]}") unless gray_logger.nil?
+              proxied_logger.send(:#{const.downcase}, *args)
+            end
+          end
+        EOT
+      end
+      private
+      def method_missing(method_name, *args, &block)
+        unless gray_logger.nil?
+          begin
+            gray_logger.send(method_name, *args, &block)
+          rescue => e
+            gray_logger.handle_exception(e)
+          end
+        end
+        unless proxied_logger.nil?
+          begin
+            proxied_logger.send(method_name, *args, &block)
+          rescue => e
+            proxied_logger.error(e.backtrace.join("\n"))
+          end
+        end
+      end
+
+    end
+
+    # config.logger = Rack::GrayLogger.after_request_proxy(SysLogger.new)
+    def self.after_request_proxy(proxied_logger)
+      self.proxy = Rack::GrayLogger::Proxy.new(:proxied_logger => proxied_logger)
+      proxy
+    end
+
+    def self.proxy= proxy
+      @proxy = proxy
+    end
+
+    def self.proxy
+      @proxy
+    end
+
+  end
+end

data/lib/gray_logger/rails_modules.rb

@@ -13,8 +13,7 @@ module GrayLogger
       # Overrides the rescue_action method in ActionController::Base, but does not inhibit
       # any custom processing that is defined with Rails 2's exception helpers.
       def rescue_action_with_gray_logger(exception)
-        gray_logger.exception_backtrace = exception.backtrace.join("\n")
-        gray_logger.short_message = "Error: #{exception.inspect}"
+        gray_logger.handle_exception(exception)
         rescue_action_without_gray_logger(exception)
       end
     end

data/lib/gray_logger/railtie.rb

@@ -5,7 +5,7 @@ module GrayLogger
     begin
       initializer "gray_logger.configure_rails_initialization" do |app|
         configuration = YAML.load(File.read(Rails.root.join('config/gray_logger.yml')))[Rails.env]
-        app.middleware.insert_after "ActionDispatch::ShowExceptions", "GrayLogger::Middleware", :configuration => configuration
+        app.middleware.insert_after "ActionDispatch::ShowExceptions", "Rack::GrayLogger::Middleware", :configuration => configuration
       end
     rescue => e
       $stderr.puts("GrayLogger not configured. Please add config/gray_logger.yml")

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gray_logger
 version: !ruby/object:Gem::Version 
-  hash: 51
+  hash: 49
   prerelease: 
   segments: 
   - 0
   - 9
-  - 4
-  version: 0.9.4
+  - 5
+  version: 0.9.5
 platform: ruby
 authors: 
 - Benjamin Behr
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-11-13 00:00:00 Z
+date: 2012-11-16 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: gelf
@@ -40,10 +40,11 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/gray_logger/bucket.rb
 - lib/gray_logger/helper_methods.rb
+- lib/gray_logger/logger.rb
 - lib/gray_logger/message.rb
-- lib/gray_logger/message_store.rb
-- lib/gray_logger/middleware.rb
+- lib/gray_logger/rack.rb
 - lib/gray_logger/rails_modules.rb
 - lib/gray_logger/railtie.rb
 - lib/gray_logger/support.rb

data/lib/gray_logger/message_store.rb

@@ -1,42 +0,0 @@
-module GrayLogger
-
-  class MessageStore
-    attr_reader :store
-
-    def initialize(store={})
-      @store = store
-    end
-
-    # gets a hash with fields
-    def add(field_set)
-      field_set.each_pair do |field, value|
-        @store[field.to_sym] = value
-      end
-      @store
-    end
-    alias_method :<<, :add
-
-    def to_message
-      GrayLogger::Message.new(@store)
-    end
-
-    protected
-    def method_missing(method_name, args, &block)
-      if method_name.to_s.end_with?("=")
-
-        # def method_name=(value)
-        #   @store[:method_name] = value
-        # end
-        instance_eval <<-EOMEVAL
-          def #{method_name}(value)
-            @store[:#{method_name.to_s.chop}] = value
-          end
-        EOMEVAL
-
-        send(method_name, args)
-      end
-    end
-
-  end
-
-end

data/lib/gray_logger/middleware.rb

@@ -1,43 +0,0 @@
-module GrayLogger
-
-  class Middleware
-    include GrayLogger::Support
-
-    attr_accessor :gray_logger
-
-    def initialize(app, options={})
-      @app = app
-      configuration = symbolize_keys(options.delete(:configuration))
-      self.gray_logger = if configuration && configuration[:host] && configuration[:port]
-        size = ENV['GRAYLOGGER_SIZE'] || configuration.delete(:size) || "WAN"
-        GELF::Logger.new(configuration.delete(:host), configuration.delete(:port), size, configuration)
-      else
-        options.delete(:logger)
-      end
-    end
-
-    def call(env)
-
-      begin
-        message_store = env["rack.gray_logger.message_store"] = GrayLogger::MessageStore.new(:level => GELF::INFO)
-        status, headers, body = @app.call(env)
-      rescue => e
-        message_store.short_message = "Error: #{e.inspect}"
-        message_store.exception_backtrace = e.backtrace.join("\n")
-        raise
-      ensure
-        error = env['rack.exception']
-        if error
-          message_store.short_message = "Error: #{error.inspect}"
-          message_store.exception_backtrace = error.backtrace.join("\n")
-        end
-        message_store.status_code = status.to_i
-        gray_logger.notify!(message_store.to_message) unless gray_logger.nil?
-        [status, headers, body]
-      end
-
-    end
-
-  end
-
-end