aboutsummaryrefslogtreecommitdiffstats
path: root/activesupport/lib/active_support/clean_logger.rb
blob: b4c27ebc9db263c61cafd997da54d69e98111d8a (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
require 'logger'
require 'active_support/core_ext/class/attribute_accessors'

# Extensions to the built in Ruby logger.
#
# If you want to use the default log formatter as defined in the Ruby core, then you 
# will need to set the formatter for the logger as in:
#
#   logger.formatter = Formatter.new
#
# You can then specify the datetime format, for example:
#
#   logger.datetime_format = "%Y-%m-%d"
#
# Note: This logger is deprecated in favor of ActiveSupport::BufferedLogger
class Logger
  # Set to false to disable the silencer
  cattr_accessor :silencer
  self.silencer = true
  
  # Silences the logger for the duration of the block.
  def silence(temporary_level = Logger::ERROR)
    if silencer
      begin
        old_logger_level, self.level = level, temporary_level
        yield self
      ensure
        self.level = old_logger_level
      end
    else
      yield self
    end
  end
  
  alias :old_datetime_format= :datetime_format=
  # Logging date-time format (string passed to +strftime+). Ignored if the formatter
  # does not respond to datetime_format=.
  def datetime_format=(datetime_format)
    formatter.datetime_format = datetime_format if formatter.respond_to?(:datetime_format=)
  end
  
  alias :old_datetime_format :datetime_format
  # Get the logging datetime format. Returns nil if the formatter does not support
  # datetime formatting.
  def datetime_format
    formatter.datetime_format if formatter.respond_to?(:datetime_format)
  end
  
  alias :old_formatter :formatter if method_defined?(:formatter)
  # Get the current formatter. The default formatter is a SimpleFormatter which only
  # displays the log message
  def formatter
    @formatter ||= SimpleFormatter.new
  end

  unless const_defined? :Formatter
    class Formatter
      Format = "%s, [%s#%d] %5s -- %s: %s\n"

      attr_accessor :datetime_format

      def initialize
        @datetime_format = nil
      end

      def call(severity, time, progname, msg)
        Format % [severity[0..0], format_datetime(time), $$, severity, progname,
        msg2str(msg)]
      end

      private
        def format_datetime(time)
          if @datetime_format.nil?
            time.strftime("%Y-%m-%dT%H:%M:%S.") << "%06d " % time.usec
          else
            time.strftime(@datetime_format)
          end
        end

        def msg2str(msg)
          case msg
          when ::String
            msg
          when ::Exception
            "#{ msg.message } (#{ msg.class })\n" <<
            (msg.backtrace || []).join("\n")
          else
            msg.inspect
          end
        end
    end
  end
  
  # Simple formatter which only displays the message.
  class SimpleFormatter < Logger::Formatter
    # This method is invoked when a log event occurs
    def call(severity, timestamp, progname, msg)
      "#{String === msg ? msg : msg.inspect}\n"
    end
  end

  private
    alias old_format_message format_message

    # Ruby 1.8.3 transposed the msg and progname arguments to format_message.
    # We can't test RUBY_VERSION because some distributions don't keep Ruby
    # and its standard library in sync, leading to installations of Ruby 1.8.2
    # with Logger from 1.8.3 and vice versa.
    if method_defined?(:formatter=)
      def format_message(severity, timestamp, progname, msg)
        formatter.call(severity, timestamp, progname, msg)
      end
    else
      def format_message(severity, timestamp, msg, progname)
        formatter.call(severity, timestamp, progname, msg)
      end
      
      attr_writer :formatter
      public :formatter=

      alias old_format_datetime format_datetime
      def format_datetime(datetime) datetime end

      alias old_msg2str msg2str
      def msg2str(msg) msg end
    end
end