gelf.fitterpen 3.1.0

data/test/test_logger.rb

@@ -0,0 +1,247 @@
+require 'helper'
+
+class TestLogger < Test::Unit::TestCase
+  context "with logger with mocked sender" do
+    setup do
+      Socket.stubs(:gethostname).returns('stubbed_hostname')
+      @logger = GELF::Logger.new
+      @sender = mock
+      @logger.instance_variable_set('@sender', @sender)
+    end
+
+    should "respond to #close" do
+      assert @logger.respond_to?(:close)
+    end
+
+    context "#add" do
+      # logger.add(Logger::INFO, nil)
+      should 'implement add method with level, message and facility from defaults' do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'gelf-rb' &&
+          hash['facility'] == 'gelf-rb'
+        end
+        @logger.add(GELF::INFO, nil)
+      end
+
+      # logger.add(Logger::INFO, 'Message')
+      should "implement add method with level and message from parameters, facility from defaults" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'Message' &&
+          hash['facility'] == 'gelf-rb'
+        end
+        @logger.add(GELF::INFO, nil, 'Message')
+      end
+
+      # logger.add(Logger::INFO, RuntimeError.new('Boom!'))
+      should "implement add method with level and exception from parameters, facility from defaults" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'RuntimeError: Boom!' &&
+          hash['full_message'] =~ /^Backtrace/ &&
+          hash['facility'] == 'gelf-rb'
+        end
+        @logger.add(GELF::INFO, nil, RuntimeError.new('Boom!'))
+      end
+
+      # logger.add(Logger::INFO) { 'Message' }
+      should "implement add method with level from parameter, message from block, facility from defaults" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'Message' &&
+          hash['facility'] == 'gelf-rb'
+        end
+        @logger.add(GELF::INFO, nil, nil) { 'Message' }
+      end
+
+      # logger.add(Logger::INFO) { RuntimeError.new('Boom!') }
+      should "implement add method with level from parameter, exception from block, facility from defaults" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'RuntimeError: Boom!' &&
+          hash['full_message'] =~ /^Backtrace/ &&
+          hash['facility'] == 'gelf-rb'
+        end
+        @logger.add(GELF::INFO, nil, nil) { RuntimeError.new('Boom!') }
+      end
+
+      # logger.add(Logger::INFO, 'Message', 'Facility')
+      should "implement add method with level, message and facility from parameters" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'Message' &&
+          hash['facility'] == 'Facility'
+        end
+        @logger.add(GELF::INFO, 'Message', 'Facility')
+      end
+
+      # logger.add(Logger::INFO, 'Message', nil)
+      should "use facility from initialization if facility is nil" do
+        logger = GELF::Logger.new('localhost', 12202, 'WAN', :facility => 'foo-bar')
+        logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'Message' &&
+          hash['facility'] == 'foo-bar'
+        end
+        logger.add(GELF::INFO, 'Message', nil)
+      end
+
+      # logger.add(Logger::INFO, 'Message', nil)
+      should "use default facility if facility is nil" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'Message' &&
+          hash['facility'] == 'gelf-rb'
+        end
+        @logger.add(GELF::INFO, 'Message', nil)
+      end
+
+      # logger.add(Logger::INFO, RuntimeError.new('Boom!'), 'Facility')
+      should "implement add method with level, exception and facility from parameters" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'RuntimeError: Boom!' &&
+          hash['full_message'] =~ /^Backtrace/ &&
+          hash['facility'] == 'Facility'
+        end
+        @logger.add(GELF::INFO, RuntimeError.new('Boom!'), 'Facility')
+      end
+
+      # logger.add(Logger::INFO, nil, 'Facility') { 'Message' }
+      should "implement add method with level and facility from parameters, message from block" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'Message' &&
+          hash['facility'] == 'Facility'
+        end
+        @logger.add(GELF::INFO, nil, 'Facility') { 'Message' }
+      end
+
+      # logger.add(Logger::INFO, nil, 'Facility') { RuntimeError.new('Boom!') }
+      should "implement add method with level and facility from parameters, exception from block" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'RuntimeError: Boom!' &&
+          hash['full_message'] =~ /^Backtrace/ &&
+          hash['facility'] == 'Facility'
+        end
+        @logger.add(GELF::INFO, nil, 'Facility') { RuntimeError.new('Boom!') }
+      end
+
+      # logger.add(Logger::INFO, { :short_message => "Some message" })
+      should "implement add method with level and message from hash, facility from defaults" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'Some message' &&
+          hash['facility'] == 'gelf-rb'
+        end
+        @logger.add(GELF::INFO, { :short_message => "Some message" })
+      end
+
+      # logger.add(Logger::INFO, { :short_message => "Some message", :_foo => "bar", "_zomg" => "wat" })
+      should "implement add method with level and message from hash, facility from defaults and some additional fields" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'Some message' &&
+          hash['facility'] == 'gelf-rb' &&
+          hash['_foo'] == 'bar' &&
+          hash['_zomg'] == 'wat'
+        end
+        @logger.add(GELF::INFO, { :short_message => "Some message", :_foo => "bar", "_zomg" => "wat"})
+      end
+
+      # logger.add(Logger::INFO, { :short_message => "Some message", :_foo => "bar", "_zomg" => "wat" }, 'somefac')
+      should "implement add method with level and message from hash, facility from parameters and some additional fields" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF::INFO &&
+          hash['short_message'] == 'Some message' &&
+          hash['facility'] == 'somefac' &&
+          hash['_foo'] == 'bar' &&
+          hash['_zomg'] == 'wat'
+        end
+        @logger.add(GELF::INFO, { :short_message => "Some message", :_foo => "bar", "_zomg" => "wat"}, "somefac")
+      end
+
+      should 'implement add method with level and ignore zero-length message strings' do
+        @logger.expects(:notify_with_level!).never
+        @logger.add(GELF::INFO, '')
+      end
+
+      should 'implement add method with level and ignore hash without short_message key' do
+        @logger.expects(:notify_with_level!).never
+        @logger.add(GELF::INFO, { :message => 'Some message' })
+      end
+
+      should 'implement add method with level and ignore hash with zero-length short_message entry' do
+        @logger.expects(:notify_with_level!).never
+        @logger.add(GELF::INFO, { :short_message => '' })
+      end
+
+      should 'implement add method with level and ignore hash with nil short_message entry' do
+        @logger.expects(:notify_with_level!).never
+        @logger.add(GELF::INFO, { :short_message => nil })
+      end
+    end
+
+    GELF::Levels.constants.each do |const|
+      # logger.error "Argument #{ @foo } mismatch."
+      should "call add with level #{const} from method name, message from parameter" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF.const_get(const) &&
+          hash['short_message'] == 'message' &&
+          hash['facility'] == 'gelf-rb'
+        end
+        @logger.__send__(const.downcase, 'message')
+      end
+
+      # logger.fatal { "Argument 'foo' not given." }
+      should "call add with level #{const} from method name, message from block" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF.const_get(const) &&
+          hash['short_message'] == 'message' &&
+          hash['facility'] == 'gelf-rb'
+        end
+        @logger.__send__(const.downcase) { 'message' }
+      end
+
+      # logger.info('initialize') { "Initializing..." }
+      should "call add with level #{const} from method name, facility from parameter, message from block" do
+        @logger.expects(:notify_with_level!).with do |level, hash|
+          level == GELF.const_get(const) &&
+          hash['short_message'] == 'message' &&
+          hash['facility'] == 'facility'
+        end
+        @logger.__send__(const.downcase, 'facility') { 'message' }
+      end
+
+      should "respond to #{const.downcase}?" do
+        @logger.level = GELF.const_get(const) - 1
+        assert @logger.__send__(const.to_s.downcase + '?')
+        @logger.level = GELF.const_get(const)
+        assert @logger.__send__(const.to_s.downcase + '?')
+        @logger.level = GELF.const_get(const) + 1
+        assert !@logger.__send__(const.to_s.downcase + '?')
+      end
+    end
+
+    should "support Logger#<<" do
+      @logger.expects(:notify_with_level!).with do |level, hash|
+        level == GELF::UNKNOWN &&
+        hash['short_message'] == "Message"
+      end
+      @logger << "Message"
+    end
+
+    should "have formatter attribute" do
+      @logger.formatter
+    end
+
+    context "close" do
+      should "close socket" do
+        @sender.expects(:close).once
+        @logger.close
+      end
+    end
+  end
+end

data/test/test_notifier.rb

@@ -0,0 +1,317 @@
+require 'helper'
+
+RANDOM_DATA = ('A'..'Z').to_a
+
+class TestNotifier < Test::Unit::TestCase
+  should "allow access to host, port, max_chunk_size and default_options" do
+    Socket.expects(:gethostname).returns('default_hostname')
+    n = GELF::Notifier.new
+    assert_equal [[['localhost', 12201]], 1420], [n.addresses, n.max_chunk_size]
+    assert_equal( { 'version' => '1.0', 'level' => GELF::UNKNOWN, 'protocol' => 0,
+                    'host' => 'default_hostname', 'facility' => 'gelf-rb' },
+                  n.default_options )
+    n.addresses, n.max_chunk_size, n.default_options = [['graylog2.org', 7777]], :lan, {:host => 'grayhost'}
+    assert_equal [['graylog2.org', 7777]], n.addresses
+    assert_equal 8154, n.max_chunk_size
+    assert_equal({'host' => 'grayhost'}, n.default_options)
+
+    n.max_chunk_size = 1337.1
+    assert_equal 1337, n.max_chunk_size
+  end
+
+  context "with notifier with mocked sender" do
+    setup do
+      Socket.stubs(:gethostname).returns('stubbed_hostname')
+      @notifier = GELF::Notifier.new('host', 12345)
+      @sender = mock
+      @notifier.instance_variable_set('@sender', @sender)
+    end
+
+    context "extract_hash" do
+      should "check arguments" do
+        assert_raise(ArgumentError) { @notifier.__send__(:extract_hash) }
+        assert_raise(ArgumentError) { @notifier.__send__(:extract_hash, 1, 2, 3) }
+      end
+
+      should "work with hash" do
+        hash = @notifier.__send__(:extract_hash, { 'version' => '1.0', 'short_message' => 'message' })
+        assert_equal '1.0', hash['version']
+        assert_equal 'message', hash['short_message']
+      end
+
+      should "work with any object which responds to #to_hash" do
+        o = Object.new
+        o.expects(:to_hash).returns({ 'version' => '1.0', 'short_message' => 'message' })
+        hash = @notifier.__send__(:extract_hash, o)
+        assert_equal '1.0', hash['version']
+        assert_equal 'message', hash['short_message']
+      end
+
+      should "work with exception with backtrace" do
+        e = RuntimeError.new('message')
+        e.set_backtrace(caller)
+        hash = @notifier.__send__(:extract_hash, e)
+        assert_equal 'RuntimeError: message', hash['short_message']
+        assert_match(/Backtrace/, hash['full_message'])
+        assert_equal GELF::ERROR, hash['level']
+      end
+
+      should "work with exception without backtrace" do
+        e = RuntimeError.new('message')
+        hash = @notifier.__send__(:extract_hash, e)
+        assert_match(/Backtrace is not available/, hash['full_message'])
+      end
+
+      should "work with exception and hash" do
+        e, h = RuntimeError.new('message'), {'param' => 1, 'level' => GELF::FATAL, 'short_message' => 'will be hidden by exception'}
+        hash = @notifier.__send__(:extract_hash, e, h)
+        assert_equal 'RuntimeError: message', hash['short_message']
+        assert_equal GELF::FATAL, hash['level']
+        assert_equal 1, hash['param']
+      end
+
+      should "work with plain text" do
+        hash = @notifier.__send__(:extract_hash, 'message')
+        assert_equal 'message', hash['short_message']
+        assert_equal GELF::INFO, hash['level']
+      end
+
+      should "work with plain text and hash" do
+        hash = @notifier.__send__(:extract_hash, 'message', 'level' => GELF::WARN)
+        assert_equal 'message', hash['short_message']
+        assert_equal GELF::WARN, hash['level']
+      end
+
+      should "covert hash keys to strings" do
+        hash = @notifier.__send__(:extract_hash, :short_message => :message)
+        assert hash.has_key?('short_message')
+        assert !hash.has_key?(:short_message)
+      end
+
+      should "not overwrite keys on convert" do
+        assert_raise(ArgumentError) { @notifier.__send__(:extract_hash, :short_message => :message1, 'short_message' => 'message2') }
+      end
+
+      should "use default_options" do
+        @notifier.default_options = {:foo => 'bar', 'short_message' => 'will be hidden by explicit argument', 'host' => 'some_host'}
+        hash = @notifier.__send__(:extract_hash, { 'version' => '1.0', 'short_message' => 'message' })
+        assert_equal 'bar', hash['foo']
+        assert_equal 'message', hash['short_message']
+      end
+
+      should "be compatible with HoptoadNotifier" do
+        # https://github.com/thoughtbot/hoptoad_notifier/blob/master/README.rdoc, section Going beyond exceptions
+        hash = @notifier.__send__(:extract_hash, :error_class => 'Class', :error_message => 'Message')
+        assert_equal 'Class: Message', hash['short_message']
+      end
+
+      should "set file and line" do
+        line = __LINE__
+        hash = @notifier.__send__(:extract_hash, { 'version' => '1.0', 'short_message' => 'message' })
+        assert_match(/test_notifier.rb/, hash['file'])
+        assert_equal line + 1, hash['line']
+      end
+
+      should "set timestamp to current time if not set" do
+        hash = @notifier.__send__(:extract_hash, { 'version' => '1.0', 'short_message' => 'message' })
+        assert_instance_of Float, hash['timestamp']
+        now = Time.now.utc.to_f
+        assert ((now - 1)..(now + 1)).include?(hash['timestamp'])
+      end
+
+      should "set timestamp to specified time" do
+        timestamp = 1319799449.13765
+        hash = @notifier.__send__(:extract_hash, { 'version' => '1.0', 'short_message' => 'message', 'timestamp' => timestamp })
+        assert_equal timestamp, hash['timestamp']
+      end
+    end
+
+    context "serialize_hash" do
+      setup do
+        @notifier.level_mapping = :direct
+        hash = { 'level' => GELF::WARN, 'field' => 'value' }
+        @data = @notifier.__send__(:serialize_hash, hash)
+        assert @data.respond_to?(:each)  # Enumerable::Enumerator in 1.8, ::Enumerator in 1.9, so...
+        @deserialized_hash = JSON.parse(Zlib::Inflate.inflate(@data.to_a.pack('C*')))
+        assert_instance_of Hash, @deserialized_hash
+      end
+
+      should "map level using mapping" do
+        assert_not_equal GELF::WARN, @deserialized_hash['level']
+        assert_not_equal GELF::LOGGER_MAPPING[GELF::WARN], @deserialized_hash['level']
+        assert_equal GELF::DIRECT_MAPPING[GELF::WARN], @deserialized_hash['level']
+      end
+    end
+
+    context "datagrams_from_hash" do
+      should "not split short data" do
+        hash = { 'version' => '1.0', 'short_message' => 'message' }
+        datagrams = @notifier.__send__(:datagrams_from_hash, hash)
+        assert_equal 1, datagrams.count
+        assert_instance_of String, datagrams[0]
+
+        asserted = "\x78\x9c"
+        if RUBY_VERSION[0,1].to_i >= 2
+          puts "I'm a Ruby > 2.0.0. Enforcing ASCII-8BIT. (#{RUBY_VERSION}/#{RUBY_VERSION[0,1].to_i})"
+          # lol well yeah, Rubby.
+          # http://stackoverflow.com/questions/15843684/binary-string-literals-in-ruby-2-0
+          asserted = asserted.b
+        end
+
+        assert_equal asserted, datagrams[0][0..1] # zlib header
+      end
+
+      should "split long data" do
+        srand(1) # for stable tests
+        hash = { 'version' => '1.0', 'short_message' => 'message' }
+        hash.merge!('something' => (0..3000).map { RANDOM_DATA[rand(RANDOM_DATA.count)] }.join) # or it will be compressed too good
+        datagrams = @notifier.__send__(:datagrams_from_hash, hash)
+        assert_equal 2, datagrams.count
+        datagrams.each_index do |i|
+          datagram = datagrams[i]
+          assert_instance_of String, datagram
+          assert datagram[0..1] == "\x1e\x0f" # chunked GELF magic number
+          # datagram[2..9] is a message id
+          assert_equal i, datagram[10].ord
+          assert_equal datagrams.count, datagram[11].ord
+        end
+      end
+
+      should "split long data when subclassed" do
+        class MyNotifier < GELF::Notifier; end
+
+        @notifier = MyNotifier.new('host', 1234)
+        @sender = mock
+        @notifier.instance_variable_set('@sender', @sender)
+
+        srand(1) # for stable tests
+        hash = { 'version' => '1.0', 'short_message' => 'message' }
+        hash.merge!('something' => (0..3000).map { RANDOM_DATA[rand(RANDOM_DATA.count)] }.join) # or it will be compressed too good
+        datagrams = @notifier.__send__(:datagrams_from_hash, hash)
+        assert_equal 2, datagrams.count
+        datagrams.each_index do |i|
+          datagram = datagrams[i]
+          assert_instance_of String, datagram
+          assert datagram[0..1] == "\x1e\x0f" # chunked GELF magic number
+          # datagram[2..9] is a message id
+          assert_equal i, datagram[10].ord
+          assert_equal datagrams.count, datagram[11].ord
+        end
+      end
+
+      should "throw an error if more than MAX_CHUNKS will be created" do
+        srand(1) # for stable tests
+        hash = { 'version' => '1.0', 'short_message' => 'message' }
+        hash.merge!('something' => (0..3000).map { RANDOM_DATA[rand(RANDOM_DATA.count)] }.join) # or it will be compressed too good
+        @notifier.max_chunk_size = 10
+        @notifier.instance_variable_set('@hash', hash)
+        assert_raise(ArgumentError) do
+          @notifier.__send__(:datagrams_from_hash)
+        end
+      end
+    end
+
+    context "level threshold" do
+      setup do
+        @notifier.level = GELF::WARN
+        @hash = { 'version' => '1.0', 'short_message' => 'message' }
+      end
+
+      ['debug', 'DEBUG', :debug].each do |l|
+        should "allow to set threshold as #{l.inspect}" do
+          @notifier.level = l
+          assert_equal GELF::DEBUG, @notifier.level
+        end
+      end
+
+      should "not send notifications with level below threshold" do
+        @sender.expects(:send_datagrams).never
+        @notifier.notify!(@hash.merge('level' => GELF::DEBUG))
+      end
+
+      should "not notifications with level equal or above threshold" do
+        @sender.expects(:send_datagrams).once
+        @notifier.notify!(@hash.merge('level' => GELF::WARN))
+      end
+    end
+
+    context "close" do
+      should "close sender" do
+        @sender.expects(:close).once
+        @notifier.close
+      end
+    end
+
+    context "when disabled" do
+      setup do
+        @notifier.disable
+      end
+
+      should "not send datagrams" do
+        @sender.expects(:send_datagrams).never
+        @notifier.expects(:extract_hash).never
+        @notifier.notify!({ 'version' => '1.0', 'short_message' => 'message' })
+      end
+
+      context "and enabled again" do
+        setup do
+          @notifier.enable
+        end
+
+        should "send datagrams" do
+          @sender.expects(:send_datagrams)
+          @notifier.notify!({ 'version' => '1.0', 'short_message' => 'message' })
+        end
+      end
+    end
+
+    should "pass valid data to sender" do
+      @sender.expects(:send_datagrams).with do |datagrams|
+        datagrams.is_a?(Array) && datagrams[0].is_a?(String)
+      end
+      @notifier.notify!({ 'version' => '1.0', 'short_message' => 'message' })
+    end
+
+    should "not mutate arguments" do
+      data = { 'version' => '1.0', 'short_message' => 'message', foo: { bar: "BAZ" } }
+      original_hash = data.hash
+
+      @sender.expects(:send_datagrams)
+      @notifier.notify!(data) 
+
+      assert_equal(data.hash, original_hash)
+    end
+
+    GELF::Levels.constants.each do |const|
+      should "call notify with level #{const} from method name" do
+        @notifier.expects(:notify_with_level).with(GELF.const_get(const), { 'version' => '1.0', 'short_message' => 'message' })
+        @notifier.__send__(const.downcase, { 'version' => '1.0', 'short_message' => 'message' })
+      end
+    end
+
+    should "not rescue from invalid invocation of #notify!" do
+      assert_raise(ArgumentError) { @notifier.notify!(:no_short_message => 'too bad') }
+    end
+
+    should "rescue from invalid invocation of #notify" do
+      @notifier.expects(:notify_with_level!).with(nil, instance_of(Hash)).raises(ArgumentError)
+      @notifier.expects(:notify_with_level!).with(GELF::UNKNOWN, instance_of(ArgumentError))
+      assert_nothing_raised { @notifier.notify(:no_short_message => 'too bad') }
+    end
+  end
+
+  context "with notifier with real sender" do
+    setup do
+      @notifier = GELF::Notifier.new('no_such_host_321')
+    end
+
+    should "raise exception" do
+      assert_raise(SocketError) { @notifier.notify('Hello!') }
+    end
+
+    should "not raise exception if asked" do
+      @notifier.rescue_network_errors = true
+      assert_nothing_raised { @notifier.notify('Hello!') }
+    end
+  end
+end

data/test/test_ruby_sender.rb

@@ -0,0 +1,28 @@
+require 'helper'
+
+class TestRubyUdpSender < Test::Unit::TestCase
+  context "with ruby sender" do
+    setup do
+      @addresses = [['localhost', 12201], ['localhost', 12202]]
+      @sender = GELF::Transport::UDP.new(@addresses)
+      @datagrams1 = %w(d1 d2 d3)
+      @datagrams2 = %w(e1 e2 e3)
+    end
+
+    context "send_datagrams" do
+      setup do
+        @sender.send_datagrams(@datagrams1)
+        @sender.send_datagrams(@datagrams2)
+      end
+
+      before_should "be called 3 times with 1st and 2nd address" do
+        UDPSocket.any_instance.expects(:send).times(3).with do |datagram, _, host, port|
+          datagram.start_with?('d') && host == 'localhost' && port == 12201
+        end
+        UDPSocket.any_instance.expects(:send).times(3).with do |datagram, _, host, port|
+          datagram.start_with?('e') && host == 'localhost' && port == 12202
+        end
+      end
+    end
+  end
+end

data/test/test_severity.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+class TestSeverity < Test::Unit::TestCase
+  should "map Ruby Logger levels to syslog levels as SyslogLogger" do
+    GELF::LOGGER_MAPPING.each do |ruby_level, syslog_level|
+      assert_not_equal syslog_level, ruby_level
+    end
+  end
+end