logjam_agent 0.6.9 → 0.7.0

data/lib/logjam_agent/buffered_logger.rb

@@ -1,16 +1,44 @@
-require 'active_support/buffered_logger'
-require 'active_support/core_ext/logger'
 require 'fileutils'
 
+if ActiveSupport::VERSION::STRING < "4.0"
+  require 'active_support/buffered_logger'
+  require 'active_support/core_ext/logger'
+else
+  require 'active_support/logger'
+
+  class LogjamAgent::ConsoleFormatter < Logger::Formatter
+    # This method is invoked when a log event occurs
+    def call(severity, timestamp, progname, msg)
+      "[#{format_time(timestamp)}] #{String === msg ? msg : msg.inspect}\n"
+    end
+
+    def format_time(timestamp)
+      timestamp.strftime("%H:%M:%S.#{"%06d" % timestamp.usec}")
+    end
+  end
+
+  class ActiveSupport::Logger
+    class << self
+      alias_method :original_broadcast, :broadcast
+      def broadcast(logger)
+        logger.formatter = LogjamAgent::ConsoleFormatter.new
+        logger.formatter.extend(ActiveSupport::TaggedLogging::Formatter)
+        original_broadcast(logger)
+      end
+    end
+  end
+end
+
 module LogjamAgent
-  class BufferedLogger < ActiveSupport::BufferedLogger
+  class BufferedLogger < ( ActiveSupport::VERSION::STRING < "4.0" ?
+                           ActiveSupport::BufferedLogger : ActiveSupport::Logger )
 
     attr_accessor :formatter
 
     def initialize(*args)
       super(*args)
       # stupid bug in the buffered logger code (Rails::VERSION::STRING < "3.2")
-      @log.write "\n" if respond_to?(:buffer)
+      @log.write "\n" if @log && respond_to?(:buffer)
       @formatter = lambda{|_, _, _, message| message}
     end
 
@@ -36,6 +64,8 @@ module LogjamAgent
 
     def add(severity, message = nil, progname = nil, &block)
       return if level > severity
+      message = progname if message.nil?
+      progname = nil # rails 3.2 bug when using tagged logging
       request = self.request || Thread.main.thread_variable_get(:logjam_request)
       if message.is_a?(Exception)
         request.add_exception(message.class.to_s) if request
@@ -51,8 +81,10 @@ module LogjamAgent
       if respond_to?(:buffer)
         buffer <<  formatted_message << "\n"
         auto_flush
-      else # @log is a logger
+      elsif @log # @log is a logger (or nil for rails 4)
         @log << "#{formatted_message}\n"
+      elsif @logdev
+        @logdev.write(formatted_message)
       end
       request.add_line(severity, time, message) if request
       message
@@ -63,7 +95,7 @@ module LogjamAgent
       if respond_to?(:buffer)
         @log = log_device
       else
-        @log.instance_eval do
+        (@log||self).instance_eval do
           raise "cannot set log device" unless defined?(@logdev)
           @logdev = log_device
         end

data/lib/logjam_agent/middleware.rb

@@ -15,7 +15,9 @@ module LogjamAgent
     ensure
       headers = result[1]
       headers["X-Logjam-Request-Id"] = request.id
-      headers["X-Logjam-Caller-Id"] = request.fields[:caller_id]
+      unless (caller_id = request.fields[:caller_id]).blank?
+        headers["X-Logjam-Caller-Id"] = caller_id
+      end
       finish_request(env)
     end
 

data/lib/logjam_agent/rack/logger.rb

@@ -4,36 +4,60 @@ module LogjamAgent
 
   module Rack
     class Logger < ActiveSupport::LogSubscriber
-      def initialize(app)
+      def initialize(app, taggers = nil)
         @app = app
+        @taggers = taggers || Rails.application.config.log_tags || []
         @hostname = LogjamAgent.hostname
       end
 
       def call(env)
+        request = ActionDispatch::Request.new(env)
+
+        if logger.respond_to?(:tagged) && !@taggers.empty?
+          logger.tagged(compute_tags(request)) { call_app(request, env) }
+        else
+          call_app(request, env)
+        end
+      end
+
+      protected
+
+      def call_app(request, env)
         start_time = Time.now
-        before_dispatch(env, start_time)
+        before_dispatch(request, env, start_time)
         result = @app.call(env)
       ensure
         run_time = Time.now - start_time
         after_dispatch(env, result, run_time*1000)
       end
 
-      protected
+      def compute_tags(request)
+        @taggers.collect do |tag|
+          case tag
+          when :uuid
+            Rails.logger.request.uuid
+          when Proc
+            tag.call(request)
+          when Symbol
+            request.send(tag)
+          else
+            tag
+          end
+        end
+      end
 
-      def before_dispatch(env, start_time)
+      def before_dispatch(request, env, start_time)
         TimeBandits.reset
-
         Thread.current.thread_variable_set(:time_bandits_completed_info, nil)
 
-        request = ActionDispatch::Request.new(env)
-
         path = request.filtered_path
 
         logjam_fields = Rails.logger.request.fields
         logjam_fields.merge!(:started_at => start_time.iso8601, :ip => request.remote_ip, :host => @hostname)
         logjam_fields.merge!(extract_request_info(request))
 
-        info "\n\nStarted #{request.request_method} \"#{path}\" for #{request.ip} at #{start_time.to_default_s}"
+        debug ""
+        info "Started #{request.request_method} \"#{path}\" for #{request.ip} at #{start_time.to_default_s}"
       end
 
       def after_dispatch(env, result, run_time_ms)
@@ -78,8 +102,8 @@ module LogjamAgent
         end
 
         result
-      rescue Exception
-        Rails.logger.error($!)
+      rescue Exception => e
+        Rails.logger.error(e)
         result
       end
 
@@ -128,7 +152,7 @@ require 'action_controller/log_subscriber'
 module ActionController #:nodoc:
 
   class LogSubscriber
-    if Rails::VERSION::STRING =~ /^3.0/
+    if Rails::VERSION::STRING =~ /\A3\.0/
       def start_processing(event)
         payload = event.payload
         params  = payload[:params].except(*INTERNAL_PARAMS)
@@ -138,14 +162,13 @@ module ActionController #:nodoc:
         full_name = "#{controller}##{action}"
         action_name = LogjamAgent.action_name_proc.call(full_name)
 
-        # puts "setting logjam action to #{action_name}"
         Rails.logger.request.fields[:action] = action_name
 
         info "  Processing by #{full_name} as #{payload[:formats].first.to_s.upcase}"
         info "  Parameters: #{params.inspect}" unless params.empty?
       end
 
-    elsif Rails::VERSION::STRING =~ /^3.1/
+    elsif Rails::VERSION::STRING =~ /\A3\.1/
 
       def start_processing(event)
         payload = event.payload
@@ -158,14 +181,13 @@ module ActionController #:nodoc:
         full_name = "#{controller}##{action}"
         action_name = LogjamAgent.action_name_proc.call(full_name)
 
-        # puts "setting logjam action to #{action_name}"
         Rails.logger.request.fields[:action] = action_name
 
         info "  Processing by #{full_name} as #{format}"
         info "  Parameters: #{params.inspect}" unless params.empty?
       end
 
-    elsif Rails::VERSION::STRING =~ /^3.2/
+    elsif Rails::VERSION::STRING =~ /\A(3\.2|4\.0)/
 
       def start_processing(event)
         payload = event.payload
@@ -178,7 +200,6 @@ module ActionController #:nodoc:
         full_name = "#{controller}##{action}"
         action_name = LogjamAgent.action_name_proc.call(full_name)
 
-        # puts "setting logjam action to #{action_name}"
         Rails.logger.request.fields[:action] = action_name
 
         info "Processing by #{full_name} as #{format}"

data/lib/logjam_agent/railtie.rb

@@ -15,13 +15,15 @@ module LogjamAgent
           paths = app.config.paths
           path = (Rails::VERSION::STRING < "3.1" ? paths.log.to_a : paths['log']).first.to_s
           logger = LogjamAgent::BufferedLogger.new(path)
-          logger.level = ActiveSupport::BufferedLogger.const_get(app.config.log_level.to_s.upcase)
+          logger.level = ::Logger.const_get(app.config.log_level.to_s.upcase)
           logger.formatter = LogjamAgent::SyslogLikeFormatter.new
           logger.auto_flushing = false if Rails.env.production? && Rails::VERSION::STRING < "3.2"
+          logger = ActiveSupport::TaggedLogging.new(logger) if Rails::VERSION::STRING >= "3.2"
           logger
-        rescue StandardError => e
+        rescue StandardError
           logger = LogjamAgent::BufferedLogger.new(STDERR)
-          logger.level = ActiveSupport::BufferedLogger::WARN
+          logger = ActiveSupport::TaggedLogging.new(logger) if Rails::VERSION::STRING >= "3.2"
+          logger.level = ::Logger::WARN
           logger.warn(
                       "Logging Error: Unable to access log file. Please ensure that #{path} exists and is writable. " +
                       "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed."

data/lib/logjam_agent/request.rb

@@ -6,7 +6,7 @@ end
 
 module LogjamAgent
   class Request
-    attr_reader :fields
+    attr_reader :fields, :uuid
 
     def initialize(app, env, logger, initial_fields)
       @logger = logger
@@ -14,13 +14,13 @@ module LogjamAgent
       @env = env
       @forwarder = Forwarders.get(app, env)
       @lines = []
-      @id = UUID4R::uuid(1).gsub('-','')
-      @fields = initial_fields.merge(:request_id => @id, :host => LogjamAgent.hostname, :process_id => Process.pid, :lines => @lines)
+      @uuid = UUID4R::uuid(1).gsub('-','')
+      @fields = initial_fields.merge(:request_id => @uuid, :host => LogjamAgent.hostname, :process_id => Process.pid, :lines => @lines)
       @mutex = Mutex.new
     end
 
     def id
-      "#{@app}-#{@env}-#{@id}"
+      "#{@app}-#{@env}-#{@uuid}"
     end
 
     def action
@@ -49,6 +49,7 @@ module LogjamAgent
 
     def forward
       engine = @fields.delete(:engine)
+      # puts @fields.inspect
       @forwarder.forward(LogjamAgent.encode_payload(@fields), :engine => engine)
     rescue Exception => e
       handle_forwarding_error(e)

data/lib/logjam_agent/syslog_like_formatter.rb

@@ -6,6 +6,7 @@ module LogjamAgent
       @hostname = LogjamAgent.hostname
       @app_name = "rails"
       @attributes = []
+      @newline = ActiveSupport::VERSION::STRING < "4.0" ? "" : "\n"
     end
 
     attr_accessor :attributes
@@ -29,7 +30,15 @@ module LogjamAgent
     end
 
     def call(severity, timestamp, progname, msg)
-      "#{format_severity(severity)} #{format_time(timestamp)} #{@hostname} #{progname||@app_name}[#{$$}]#{render_attributes}: #{format_message(msg)}"
+      "#{format_severity(severity)} #{format_time(timestamp)}#{render_attributes}#{format_host_info(progname)}: #{format_message(msg)}#{@newline}"
+    end
+
+    if Rails.env.development?
+      def format_host_info(proganme); ""; end
+    else
+      def format_host_info(proganme)
+       " #{@hostname} #{progname||@app_name}[#{$$}]"
+      end
     end
 
     def render_attributes

data/lib/logjam_agent/version.rb

@@ -1,3 +1,3 @@
 module LogjamAgent
-  VERSION = "0.6.9"
+  VERSION = "0.7.0"
 end

data/logjam_agent.gemspec

@@ -23,5 +23,5 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency "activesupport"
   s.add_runtime_dependency "uuid4r"
-  s.add_runtime_dependency "time_bandits", [">= 0.3"]
+  s.add_runtime_dependency "time_bandits", [">= 0.4"]
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: logjam_agent
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 3
   prerelease: 
   segments: 
   - 0
-  - 6
-  - 9
-  version: 0.6.9
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Stefan Kaes
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-05-29 00:00:00 Z
+date: 2013-07-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake
@@ -81,11 +81,11 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 13
+        hash: 3
         segments: 
         - 0
-        - 3
-        version: "0.3"
+        - 4
+        version: "0.4"
   type: :runtime
   version_requirements: *id005
 description: Logjam logger and request information forwarding