logging 1.8.2 → 2.0.0

data/lib/logging/stats.rb

@@ -1,277 +0,0 @@
-# Simple statistics collection and logging module.
-#
-module Logging::Stats
-
-  # A very simple little class for doing some basic fast statistics
-  # sampling. You feed it either samples of numeric data you want measured
-  # or you call Sampler#tick to get it to add a time delta between the last
-  # time you called it. When you're done either call sum, sumsq, num, min,
-  # max, mean or sd to get the information. The other option is to just
-  # call to_s and see everything.
-  #
-  # It does all of this very fast and doesn't take up any memory since the
-  # samples are not stored but instead all the values are calculated on the
-  # fly.
-  #
-  class Sampler
-
-    attr_reader :name, :sum, :sumsq, :num, :min, :max, :last
-
-    # Create a new sampler.
-    #
-    def initialize( name )
-      @name = name
-      reset
-    end
-
-    # Resets the internal counters so you can start sampling again.
-    #
-    def reset
-      @sum = 0.0
-      @sumsq = 0.0
-      @num = 0
-      @min = 0.0
-      @max = 0.0
-      @last = nil
-      @last_time = Time.now.to_f
-      self
-    end
-
-    # Coalesce the statistics from the _other_ sampler into this one. The
-    # _other_ sampler is not modified by this method.
-    #
-    # Coalescing the same two samplers multiple times should only be done if
-    # one of the samplers is reset between calls to this method. Otherwise
-    # statistics will be counted multiple times.
-    #
-    def coalesce( other )
-      @sum += other.sum
-      @sumsq += other.sumsq
-      if other.num > 0
-        @min = other.min if @min > other.min
-        @max = other.max if @max < other.max
-        @last = other.last
-      end
-      @num += other.num
-    end
-
-    # Adds a sampling to the calculations.
-    #
-    def sample( s )
-      @sum += s
-      @sumsq += s * s
-      if @num == 0
-        @min = @max = s
-      else
-        @min = s if @min > s
-        @max = s if @max < s
-      end
-      @num += 1
-      @last = s
-    end
-
-    # Returns statistics in a common format.
-    #
-    def to_s
-      "[%s]: SUM=%0.6f, SUMSQ=%0.6f, NUM=%d, MEAN=%0.6f, SD=%0.6f, MIN=%0.6f, MAX=%0.6f" % to_a
-    end
-
-    # An array of the values: [name,sum,sumsq,num,mean,sd,min,max]
-    #
-    def to_a
-      [name, sum, sumsq, num, mean, sd, min, max]
-    end
-
-    # Class method that returns the headers that a CSV file would have for the
-    # values that this stats object is using.
-    #
-    def self.keys
-      %w[name sum sumsq num mean sd min max]
-    end
-
-    def to_hash
-      {:name => name, :sum => sum, :sumsq => sumsq, :num => num,
-       :mean => mean, :sd => sd, :min => min, :max => max}
-    end
-
-    # Calculates and returns the mean for the data passed so far.
-    #
-    def mean
-      return 0.0 if num < 1
-      sum / num
-    end
-
-    # Calculates the standard deviation of the data so far.
-    #
-    def sd
-      return 0.0 if num < 2
-
-      # (sqrt( ((s).sumsq - ( (s).sum * (s).sum / (s).num)) / ((s).num-1) ))
-      begin
-        return Math.sqrt( (sumsq - ( sum * sum / num)) / (num-1) )
-      rescue Errno::EDOM
-        return 0.0
-      end
-    end
-
-    # You can just call tick repeatedly if you need the delta times
-    # between a set of sample periods, but many times you actually want
-    # to sample how long something takes between a start/end period.
-    # Call mark at the beginning and then tick at the end you'll get this
-    # kind of measurement.  Don't mix mark/tick and tick sampling together
-    # or the measurement will be meaningless.
-    #
-    def mark
-      @last_time = Time.now.to_f
-    end
-
-    # Adds a time delta between now and the last time you called this.  This
-    # will give you the average time between two activities.
-    #
-    # An example is:
-    #
-    #  t = Sampler.new("do_stuff")
-    #  10000.times { do_stuff(); t.tick }
-    #  t.dump("time")
-    #
-    def tick
-      now = Time.now.to_f
-      sample(now - @last_time)
-      @last_time = now
-    end
-  end  # class Sampler
-
-  # The Tracker class provides synchronized access to a collection of
-  # related samplers.
-  #
-  class Tracker
-
-    attr_reader :stats
-
-    # Create a new Tracker instance. An optional boolean can be passed in to
-    # change the "threadsafe" value of the tracker. By default all trackers
-    # are created to be threadsafe.
-    #
-    def initialize( threadsafe = true )
-      @stats = Hash.new do |h,name|
-        h[name] = ::Logging::Stats::Sampler.new(name)
-      end
-      @mutex = threadsafe ? ReentrantMutex.new : nil
-      @runner = nil
-    end
-
-    # Coalesce the samplers from the _other_ tracker into this one. The
-    # _other_ tracker is not modified by this method.
-    #
-    # Coalescing the same two trackers multiple times should only be done if
-    # one of the trackers is reset between calls to this method. Otherwise
-    # statistics will be counted multiple times.
-    #
-    # Only this tracker is locked when the coalescing is happening. It is
-    # left to the user to lock the other tracker if that is the desired
-    # behavior. This is a deliberate choice in order to prevent deadlock
-    # situations where two threads are contending on the same mutex.
-    #
-    def coalesce( other )
-      sync {
-        other.stats.each do |name,sampler|
-          stats[name].coalesce(sampler)
-        end
-      }
-    end
-
-    # Add the given _value_ to the named _event_ sampler. The sampler will
-    # be created if it does not exist.
-    #
-    def sample( event, value )
-      sync {stats[event].sample(value)}
-    end
-
-    # Mark the named _event_ sampler. The sampler will be created if it does
-    # not exist.
-    #
-    def mark( event )
-      sync {stats[event].mark}
-    end
-
-    # Tick the named _event_ sampler. The sampler will be created if it does
-    # not exist.
-    #
-    def tick( event )
-      sync {stats[event].tick}
-    end
-
-    # Time the execution of the given block and store the results in the
-    # named _event_ sampler. The sampler will be created if it does not
-    # exist.
-    #
-    def time( event )
-      sync {stats[event].mark}
-      yield
-    ensure
-      sync {stats[event].tick}
-    end
-
-    # Reset all the samplers managed by this tracker.
-    #
-    def reset
-      sync {stats.each_value {|sampler| sampler.reset}}
-      self
-    end
-
-    # Periodically execute the given _block_ at the given _period_. The
-    # tracker will be locked while the block is executing.
-    #
-    # This method is useful for logging statistics at given interval.
-    #
-    # Example
-    #
-    #    periodically_run( 300 ) {
-    #      logger = Logging::Logger['stats']
-    #      tracker.each {|sampler| logger << sampler.to_s}
-    #      tracker.reset
-    #    }
-    #
-    def periodically_run( period, &block )
-      raise ArgumentError, 'a runner already exists' unless @runner.nil?
-
-      @runner = Thread.new do
-        start = stop = Time.now.to_f
-        loop do
-          seconds = period - (stop-start)
-          seconds = period if seconds <= 0
-          sleep seconds
-
-          start = Time.now.to_f
-          break if Thread.current[:stop] == true
-          if @mutex then @mutex.synchronize(&block)
-          else block.call end
-          stop = Time.now.to_f
-        end
-      end
-    end
-
-    # Stop the current periodic runner if present.
-    #
-    def stop
-      return if @runner.nil?
-      @runner[:stop] = true
-      @runner.wakeup if @runner.status
-      @runner = nil
-    end
-
-    # call-seq:
-    #    sync { block }
-    #
-    # Obtains an exclusive lock, runs the block, and releases the lock when
-    # the block completes. This method is re-entrant so that a single thread
-    # can call +sync+ multiple times without hanging the thread.
-    #
-    def sync
-      return yield if @mutex.nil?
-      @mutex.synchronize {yield}
-    end
-  end  # class Tracker
-
-end  # module Logging::Stats
-

data/test/appenders/test_email.rb

@@ -1,170 +0,0 @@
-
-require File.expand_path('../setup', File.dirname(__FILE__))
-require 'flexmock'
-
-module TestLogging
-module TestAppenders
-
-  class TestEmail < Test::Unit::TestCase
-    include FlexMock::TestCase
-    include LoggingTestCase
-
-    def setup
-      super
-
-      flexmock(Net::SMTP).new_instances do |m|
-        m.should_receive(:start).at_least.once.with(
-            'test.logging', 'test', 'test', :plain, Proc).and_yield(m)
-        m.should_receive(:sendmail).at_least.once.with(String, 'me', ['you'])
-      end
-
-      @appender = Logging.appenders.email('email',
-          'from' => 'me', 'to' => 'you',
-          :buffer_size => '3', :immediate_at => 'error, fatal',
-          :domain => 'test.logging', :user_name => 'test', :password => 'test'
-      )
-      @levels = Logging::LEVELS
-    end
-
-    def test_initialize
-      assert_raise(ArgumentError, 'Must specify from address') {
-        Logging.appenders.email('email')
-      }
-      assert_raise(ArgumentError, 'Must specify to address') {
-        Logging.appenders.email('email', :from => 'me')
-      }
-      assert_nothing_raised {
-        Logging.appenders.email('email', :from => 'me', :to => 'you')
-      }
-
-      appender = Logging.appenders.email('email',
-          'from' => 'me', 'to' => 'you'
-      )
-
-      assert_equal(100, appender.auto_flushing)
-      assert_equal([], appender.instance_variable_get(:@immediate))
-      assert_equal('localhost', appender.address)
-      assert_equal(25, appender.port)
-
-      domain = ENV['HOSTNAME'] || 'localhost.localdomain'
-      assert_equal(domain, appender.domain)
-      assert_equal(nil, appender.user_name)
-      assert_equal(:plain, appender.authentication)
-      assert_equal("Message from #{$0}", appender.subject)
-
-      appender = Logging.appenders.email('email',
-          'from' => 'lbrinn@gmail.com', 'to' => 'everyone',
-          :buffsize => '1000', :immediate_at => 'error, fatal',
-          :address => 'smtp.google.com', :port => '443',
-          :domain => 'google.com', :user_name => 'lbrinn',
-          :password => '1234', :authentication => 'plain', :enable_starttls_auto => true,
-          :subject => "I'm rich and you're not"
-      )
-
-      assert_equal('lbrinn@gmail.com', appender.instance_variable_get(:@from))
-      assert_equal(['everyone'], appender.instance_variable_get(:@to))
-      assert_equal(1000, appender.auto_flushing)
-      assert_equal('1234', appender.password)
-      assert_equal([nil, nil, nil, true, true],
-                   appender.instance_variable_get(:@immediate))
-      assert_equal('smtp.google.com', appender.address)
-      assert_equal(443, appender.port)
-      assert_equal('google.com', appender.domain)
-      assert_equal('lbrinn', appender.user_name)
-      assert_equal(:plain, appender.authentication)
-      assert(appender.enable_starttls_auto)
-      assert_equal("I'm rich and you're not", appender.subject)
-
-      appender = Logging.appenders.email('email',
-          'from' => 'me', 'to' => 'you', :auto_flushing => 42
-      )
-      assert_equal(42, appender.auto_flushing)
-    end
-
-    def test_append
-      # with auto_flushing enabled, mail will be sent each time a log event
-      # occurs
-      @appender.auto_flushing = true
-      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                    [1, 2, 3, 4], false)
-      @appender.append event
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-
-      # increase the buffer size and log a few events
-      @appender.auto_flushing = 3
-      @appender.append event
-      @appender.append event
-      assert_equal(2, @appender.buffer.length)
-
-      @appender.append event
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-
-      # error and fatal messages should be send immediately (no buffering)
-      error = Logging::LogEvent.new('ErrLogger', @levels['error'],
-                                    'error message', false)
-      fatal = Logging::LogEvent.new('FatalLogger', @levels['fatal'],
-                                    'fatal message', false)
-
-      @appender.append event
-      @appender.append fatal
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-
-      @appender.append error
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-
-      @appender.append event
-      assert_equal(1, @appender.buffer.length)
-    end
-
-    def test_concat
-      # with auto_flushing enabled, mail will be sent each time a log event
-      # occurs
-      @appender.auto_flushing = true
-      @appender << 'test message'
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-
-      # increase the buffer size and log a few events
-      @appender.auto_flushing = 3
-      @appender << 'another test message'
-      @appender << 'a second test message'
-      assert_equal(2, @appender.buffer.length)
-
-      @appender << 'a third test message'
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-    end
-
-    def test_flush
-      event = Logging::LogEvent.new('TestLogger', @levels['info'],
-                                    [1, 2, 3, 4], false)
-      @appender.append event
-      @appender << 'test message'
-      assert_equal(2, @appender.buffer.length)
-
-      @appender.flush
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-    end
-
-    def test_close
-      event = Logging::LogEvent.new('TestLogger', @levels['info'],
-                                    [1, 2, 3, 4], false)
-      @appender.append event
-      @appender << 'test message'
-      assert_equal(2, @appender.buffer.length)
-
-      @appender.close
-      assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.buffer.length)
-      assert(@appender.closed?)
-    end
-
-  end  # class TestEmail
-end  # module TestLogging
-end  # module TestAppenders
-

data/test/appenders/test_growl.rb

@@ -1,138 +0,0 @@
-
-require File.expand_path('../setup', File.dirname(__FILE__))
-require 'flexmock'
-
-module TestLogging
-module TestAppenders
-
-  class TestGrowl < Test::Unit::TestCase
-    include FlexMock::TestCase
-    include LoggingTestCase
-
-    def setup
-      super
-
-      @appender = Logging.appenders.growl('growl',
-          :coalesce => true, :separator => "\000",
-          :layout => Logging.layouts.pattern(:pattern => "%5l - Test\000%m")
-      )
-      @appender.level = :all
-      @growl = @appender.instance_variable_get(:@growl).dup
-      @levels = Logging::LEVELS
-    end
-
-    def test_initialize
-      assert_equal('growlnotify -w -n "growl" -t "%s" -m "%s" -p %d &', @growl)
-      assert_equal(true, @appender.instance_variable_get(:@coalesce))
-      assert_equal("\000", @appender.instance_variable_get(:@title_sep))
-    end
-
-    def test_append
-      info = Logging::LogEvent.new('TestLogger', @levels['info'],
-                                   'info message', false)
-      warn = Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                   'warning message', false)
-
-      flexmock(@appender).should_receive(:system => true).once.with(
-          @growl % ['WARN - Test', "warning message\nwarning message\nwarning message", 0])
-
-      flexmock(@appender).should_receive(:system => true).once.with(
-          @growl % ['INFO - Test', "info message\ninfo message", -1])
-
-      flexmock(@appender).should_receive(:system => true).once.with(
-          @growl % ['WARN - Test', "warning message", 0])
-
-      @appender.append warn
-      @appender.append warn
-      @appender.append warn
-      @appender.append info
-      @appender.append info
-      @appender.append warn
-      ensure_queue_is_empty
-    end
-
-    def test_append_without_coalescing
-      @appender.instance_variable_set(:@coalesce, false)
-      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                    'warning message', false)
-
-      flexmock(@appender).should_receive(:system => true).twice.with(
-          @growl % ['WARN - Test', 'warning message', 0])
-
-      @appender.append event
-      @appender.append event
-    end
-
-    def test_concat
-      flexmock(@appender).should_receive(:system => true).once.with(
-          @growl % ['', "first message\nsecond message\nthird message", 0])
-
-      @appender << 'first message'
-      @appender << 'second message'
-      @appender << 'third message'
-      ensure_queue_is_empty
-    end
-
-    def test_concat_without_coalescing
-      @appender.instance_variable_set(:@coalesce, false)
-
-      flexmock(@appender).should_receive(:system => true).twice.with(
-          @growl % ['', 'concat message', 0])
-
-      @appender << 'concat message'
-      @appender << 'concat message'
-    end
-
-    def test_map_eq
-      get_map = lambda {@appender.instance_variable_get(:@map)}
-      assert_equal([-2,-1,0,1,2], get_map.call)
-
-      @appender.map = {
-        'fatal' => '0',
-        :error => -2,
-        :warn => '2',
-        'INFO' => 1,
-        'Debug' => -1
-      }
-      assert_equal([-1,1,2,-2,0], get_map.call)
-
-      assert_raise(ArgumentError) do
-        @appender.map = {:fatal => 'not a number', :error => 2}
-      end
-
-      assert_raise(ArgumentError) do
-        @appender.map = {:fatal => -3, :error => 3}
-      end
-    end
-
-    def test_disabling
-      @appender.instance_variable_set(:@coalesce, false)
-      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                    'warning message', false)
-
-      flexmock(@appender).should_receive(:system => false).once.with(
-          @growl % ['WARN - Test', 'warning message', 0])
-
-      assert_equal 0, @appender.level
-      @appender.append event
-      assert_equal 5, @appender.level
-      @appender.append event
-      @appender.append event
-    end
-
-  private
-
-    def ensure_queue_is_empty
-      start = Time.now
-
-      queue = @appender.instance_variable_get :@c_queue
-      sleep 0.2 until queue.empty? or (Time.now - start > 10)
-
-      thread = @appender.instance_variable_get :@c_thread
-      sleep 0.2 until thread.status == 'sleep' or (Time.now - start > 10)
-    end
-
-  end  # class TestGrowl
-end  # module TestLogging
-end  # module TestAppenders
-