gelf 1.1.0.gamma1 → 1.1.0.rc1

data/CHANGELOG

@@ -4,7 +4,7 @@
    * requires graylog2-web-interface version XXXXXXXXXXXX;
  + Notifier#default_options;
  + severity (level) threshold;
- + automatically set '_file', '_line' and '_timestamp', fields;
+ + automatically set '_file', '_line' and '_timestamp' fields;
  + wrappers for GELF::Notifier#notify with severity:
    + GELF::Notifier.debug
    + GELF::Notifier.info

data/VERSION

@@ -1 +1 @@
-1.1.0.gamma1
+1.1.0.rc1

data/gelf.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gelf}
-  s.version = "1.1.0.gamma1"
+  s.version = "1.1.0.rc1"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Aleksey Palazhchenko", "Lennart Koopmann"]
-  s.date = %q{2010-12-09}
+  s.date = %q{2011-01-08}
   s.description = %q{Library to send GELF messages to Graylog2 logging server. Supports plain-text, GELF messages and exceptions.}
   s.email = %q{aleksey.palazhchenko@gmail.com}
   s.extra_rdoc_files = [
@@ -46,11 +46,11 @@ Gem::Specification.new do |s|
   s.summary = %q{Library to send GELF messages to Graylog2 logging server.}
   s.test_files = [
     "test/helper.rb",
-     "test/test_deprecations.rb",
      "test/test_logger.rb",
      "test/test_notifier.rb",
+     "test/test_severity.rb",
      "test/test_ruby_sender.rb",
-     "test/test_severity.rb"
+     "test/test_deprecations.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/gelf/logger.rb

@@ -20,7 +20,7 @@ module GELF
                             [args[0], nil]
                           end
 
-      hash = {'_short_message' => message, '_facility' => facility}
+      hash = {'short_message' => message, 'facility' => facility}
       hash.merge!(self.class.extract_hash_from_exception(message)) if message.is_a?(Exception)
       notify_with_level(level, hash)
     end
@@ -40,7 +40,7 @@ module GELF
     end
 
     def <<(message)
-      notify('_short_message' => message, '_level' => GELF::UNKNOWN)
+      notify('short_message' => message, 'level' => GELF::UNKNOWN)
     end
   end
 

data/lib/gelf/notifier.rb

@@ -19,12 +19,11 @@ module GELF
 
       self.host, self.port, self.max_chunk_size = host, port, max_size
 
-      @default_options = {}
       self.default_options = default_options
-      self.default_options['_version'] = SPEC_VERSION
-      self.default_options['_host'] ||= Socket.gethostname
-      self.default_options['_level'] ||= GELF::DEBUG
-      self.default_options['_facility'] ||= 'gelf-rb'
+      self.default_options['version'] = SPEC_VERSION
+      self.default_options['host'] ||= Socket.gethostname
+      self.default_options['level'] ||= GELF::UNKNOWN
+      self.default_options['facility'] ||= 'gelf-rb'
 
       @sender = RubyUdpSender.new(host, port)
     end
@@ -96,8 +95,8 @@ module GELF
     def notify_with_level!(message_level, *args)
       return unless @enabled
       extract_hash(*args)
-      @hash['_level'] = message_level unless message_level.nil?
-      if @hash['_level'] >= level
+      @hash['level'] = message_level unless message_level.nil?
+      if @hash['level'] >= level
         @sender.send_datagrams(datagrams_from_hash)
       end
     end
@@ -106,11 +105,11 @@ module GELF
       primary_data = if object.respond_to?(:to_hash)
                        object.to_hash
                      elsif object.is_a?(Exception)
-                       args['_level'] ||= GELF::ERROR
+                       args['level'] ||= GELF::ERROR
                        self.class.extract_hash_from_exception(object)
                      else
-                       args['_level'] ||= GELF::INFO
-                       { '_short_message' => object.to_s }
+                       args['level'] ||= GELF::INFO
+                       { 'short_message' => object.to_s }
                      end
 
       @hash = default_options.merge(args.merge(primary_data))
@@ -124,16 +123,14 @@ module GELF
 
     def self.extract_hash_from_exception(exception)
       bt = exception.backtrace || ["Backtrace is not available."]
-      { '_short_message' => "#{exception.class}: #{exception.message}", '_full_message' => "Backtrace:\n" + bt.join("\n") }
+      { 'short_message' => "#{exception.class}: #{exception.message}", 'full_message' => "Backtrace:\n" + bt.join("\n") }
     end
 
     # Converts Hoptoad-specific keys in +@hash+ to Graylog2-specific.
     def convert_hoptoad_keys_to_graylog2
-      if @hash['_short_message'].to_s.empty?
+      if @hash['short_message'].to_s.empty?
         if @hash.has_key?('error_class') && @hash.has_key?('error_message')
-          @hash['_short_message'] = "#{@hash['error_class']}: #{@hash['error_message']}"
-          @hash.delete('error_class')
-          @hash.delete('error_message')
+          @hash['short_message'] = @hash.delete('error_class') + ': ' + @hash.delete('error_message')
         end
       end
     end
@@ -147,28 +144,24 @@ module GELF
         frame = stack.shift
       end while frame.include?(LIB_GELF_PATTERN)
       match = CALLER_REGEXP.match(frame)
-      @hash['_file'] = match[1]
-      @hash['_line'] = match[2].to_i
+      @hash['file'] = match[1]
+      @hash['line'] = match[2].to_i
     end
 
     def set_timestamp
-      @hash['_timestamp'] = Time.now.utc.to_f
+      @hash['timestamp'] = Time.now.utc.to_f
     end
 
     def check_presence_of_mandatory_attributes
-      %w(_version _short_message _host).each do |attribute|
+      %w(version short_message host).each do |attribute|
         if @hash[attribute].to_s.empty?
-          raise ArgumentError.new("#{attribute} is missing. Options _version, _short_message and _host must be set.")
+          raise ArgumentError.new("#{attribute} is missing. Options version, short_message and host must be set.")
         end
       end
     end
 
     def datagrams_from_hash
-      raise ArgumentError.new("Hash is empty.") if @hash.nil? || @hash.empty?
-
-      @hash['_level'] = GELF::LEVELS_MAPPING[@hash['_level']]
-
-      data = Zlib::Deflate.deflate(@hash.to_json).bytes
+      data = serialize_hash
       datagrams = []
 
       # Maximum total size is 8192 byte for UDP datagram. Split to chunks if bigger. (GELFv2 supports chunking)
@@ -177,18 +170,22 @@ module GELF
         msg_id = Digest::MD5.digest("#{Time.now.to_f}-#{id}")[0, 8]
         num, count = 0, (data.count.to_f / @max_chunk_size).ceil
         data.each_slice(@max_chunk_size) do |slice|
-          datagrams << self.class.chunk_data(slice, msg_id, num, count)
+          datagrams << "\x1e\x0f" + msg_id + [num, count, *slice].pack('C*')
           num += 1
         end
       else
-        datagrams = [data.map(&:chr).join]
+        datagrams << data.to_a.pack('C*')
       end
 
       datagrams
     end
 
-    def self.chunk_data(data, msg_id, num, count)
-      return "\x1e\x0f" + msg_id + [num, count, *data].pack('C*')
+    def serialize_hash
+      raise ArgumentError.new("Hash is empty.") if @hash.nil? || @hash.empty?
+
+      @hash['level'] = GELF::LEVELS_MAPPING[@hash['level']]
+
+      Zlib::Deflate.deflate(@hash.to_json).bytes
     end
 
     def stringify_hash_keys

data/lib/gelf/ruby_sender.rb

@@ -14,16 +14,16 @@ module GELF
   end
 
   # Plain Ruby TCP sender.
-  class RubyTcpSender
-    def initialize(host, port)
-      @host, @port = host, port
-      @socket = TCPSocket.open
-    end
-
-    def send_datagrams(datagrams)
-      datagrams.each do |datagram|
-        @socket.send(datagram, 0, @host, @port)
-      end
-    end
-  end
+  # class RubyTcpSender
+  #   def initialize(host, port)
+  #     @host, @port = host, port
+  #     @socket = TCPSocket.open
+  #   end
+  #
+  #   def send_datagrams(datagrams)
+  #     datagrams.each do |datagram|
+  #       @socket.send(datagram, 0, @host, @port)
+  #     end
+  #   end
+  # end
 end

data/test/test_logger.rb

@@ -18,7 +18,7 @@ class TestLogger < Test::Unit::TestCase
       should "implement add method with level and message from parameters" do
         @notifier.expects(:notify_with_level!).with do |level, hash|
           level == GELF::INFO &&
-          hash['_short_message'] == 'Message'
+          hash['short_message'] == 'Message'
         end
         @notifier.add(GELF::INFO, 'Message')
       end
@@ -27,8 +27,8 @@ class TestLogger < Test::Unit::TestCase
       should "implement add method with level and exception from parameters" do
         @notifier.expects(:notify_with_level!).with do |level, hash|
           level == GELF::INFO &&
-          hash['_short_message'] == 'RuntimeError: Boom!' &&
-          hash['_full_message'] =~ /^Backtrace/
+          hash['short_message'] == 'RuntimeError: Boom!' &&
+          hash['full_message'] =~ /^Backtrace/
         end
         @notifier.add(GELF::INFO, RuntimeError.new('Boom!'))
       end
@@ -37,7 +37,7 @@ class TestLogger < Test::Unit::TestCase
       should "implement add method with level from parameter and message from block" do
         @notifier.expects(:notify_with_level!).with do |level, hash|
           level == GELF::INFO &&
-          hash['_short_message'] == 'Message'
+          hash['short_message'] == 'Message'
         end
         @notifier.add(GELF::INFO) { 'Message' }
       end
@@ -46,8 +46,8 @@ class TestLogger < Test::Unit::TestCase
       should "implement add method with level from parameter and exception from block" do
         @notifier.expects(:notify_with_level!).with do |level, hash|
           level == GELF::INFO &&
-          hash['_short_message'] == 'RuntimeError: Boom!' &&
-          hash['_full_message'] =~ /^Backtrace/
+          hash['short_message'] == 'RuntimeError: Boom!' &&
+          hash['full_message'] =~ /^Backtrace/
         end
         @notifier.add(GELF::INFO) { RuntimeError.new('Boom!') }
       end
@@ -56,8 +56,8 @@ class TestLogger < Test::Unit::TestCase
       should "implement add method with level, message and facility from parameters" do
         @notifier.expects(:notify_with_level!).with do |level, hash|
           level == GELF::INFO &&
-          hash['_short_message'] == 'Message' &&
-          hash['_facility'] == 'Facility'
+          hash['short_message'] == 'Message' &&
+          hash['facility'] == 'Facility'
         end
         @notifier.add(GELF::INFO, 'Message', 'Facility')
       end
@@ -66,9 +66,9 @@ class TestLogger < Test::Unit::TestCase
       should "implement add method with level, exception and facility from parameters" do
         @notifier.expects(:notify_with_level!).with do |level, hash|
           level == GELF::INFO &&
-          hash['_short_message'] == 'RuntimeError: Boom!' &&
-          hash['_full_message'] =~ /^Backtrace/ &&
-          hash['_facility'] == 'Facility'
+          hash['short_message'] == 'RuntimeError: Boom!' &&
+          hash['full_message'] =~ /^Backtrace/ &&
+          hash['facility'] == 'Facility'
         end
         @notifier.add(GELF::INFO, RuntimeError.new('Boom!'), 'Facility')
       end
@@ -77,8 +77,8 @@ class TestLogger < Test::Unit::TestCase
       should "implement add method with level and facility from parameters and message from block" do
         @notifier.expects(:notify_with_level!).with do |level, hash|
           level == GELF::INFO &&
-          hash['_short_message'] == 'Message' &&
-          hash['_facility'] == 'Facility'
+          hash['short_message'] == 'Message' &&
+          hash['facility'] == 'Facility'
         end
         @notifier.add(GELF::INFO, 'Facility') { 'Message' }
       end
@@ -87,9 +87,9 @@ class TestLogger < Test::Unit::TestCase
       should "implement add method with level and facility from parameters and exception from block" do
         @notifier.expects(:notify_with_level!).with do |level, hash|
           level == GELF::INFO &&
-          hash['_short_message'] == 'RuntimeError: Boom!' &&
-          hash['_full_message'] =~ /^Backtrace/ &&
-          hash['_facility'] == 'Facility'
+          hash['short_message'] == 'RuntimeError: Boom!' &&
+          hash['full_message'] =~ /^Backtrace/ &&
+          hash['facility'] == 'Facility'
         end
         @notifier.add(GELF::INFO, 'Facility') { RuntimeError.new('Boom!') }
       end
@@ -126,8 +126,8 @@ class TestLogger < Test::Unit::TestCase
 
     should "support Notifier#<<" do
       @notifier.expects(:notify_with_level!).with do |nil_, hash|
-        hash['_short_message'] == "Message" &&
-        hash['_level'] == GELF::UNKNOWN
+        hash['short_message'] == "Message" &&
+        hash['level'] == GELF::UNKNOWN
       end
       @notifier << "Message"
     end

data/test/test_notifier.rb

@@ -7,12 +7,12 @@ class TestNotifier < Test::Unit::TestCase
     Socket.expects(:gethostname).returns('default_hostname')
     n = GELF::Notifier.new
     assert_equal ['localhost', 12201, 1420], [n.host, n.port, n.max_chunk_size]
-    assert_equal( { '_version' => '1.0', '_level' => GELF::DEBUG,
-                    '_host' => 'default_hostname', '_facility' => 'gelf-rb' },
+    assert_equal( { 'version' => '1.0', 'level' => GELF::UNKNOWN,
+                    'host' => 'default_hostname', 'facility' => 'gelf-rb' },
                   n.default_options )
-    n.host, n.port, n.max_chunk_size, n.default_options = 'graylog2.org', 7777, :lan, {'_host' => 'grayhost'}
+    n.host, n.port, n.max_chunk_size, n.default_options = 'graylog2.org', 7777, :lan, {'host' => 'grayhost'}
     assert_equal ['graylog2.org', 7777, 8154], [n.host, n.port, n.max_chunk_size]
-    assert_equal({'_host' => 'grayhost'}, n.default_options)
+    assert_equal({'host' => 'grayhost'}, n.default_options)
 
     n.max_chunk_size = 1337.1
     assert_equal 1337, n.max_chunk_size
@@ -33,108 +33,126 @@ class TestNotifier < Test::Unit::TestCase
       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']
+        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' })
+        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']
+        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']
+        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']
+        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'}
+        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 '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']
+        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']
+        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)
+        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') }
+        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' })
+        @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']
+        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']
+        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']
+        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" do
-        hash = @notifier.__send__(:extract_hash, { '_version' => '1.0', '_short_message' => 'message' })
+        hash = @notifier.__send__(:extract_hash, { 'version' => '1.0', 'short_message' => 'message' })
+        assert_instance_of Float, hash['timestamp']
         now = Time.now.utc.to_i
-        assert ((now - 1)..(now + 1)).include?(hash['_timestamp'])
+        assert ((now - 1)..(now + 1)).include?(hash['timestamp'])
+      end
+    end
+
+    context "serialize_hash" do
+      setup do
+        @notifier.instance_variable_set('@hash', { 'level' => GELF::WARN, 'field' => 'value' })
+        @data = @notifier.__send__(:serialize_hash)
+        assert_instance_of Enumerable::Enumerator, @data
+        @deserialized_hash = JSON.parse(Zlib::Inflate.inflate(@data.to_a.pack('C*')))
+        assert_instance_of Hash, @deserialized_hash
+      end
+
+      should "map level" do
+        assert_not_equal GELF::WARN, @deserialized_hash['level']
+        assert_equal GELF::LEVELS_MAPPING[GELF::WARN], @deserialized_hash['level']
       end
     end
 
     context "datagrams_from_hash" do
       should "not split short data" do
-        @notifier.instance_variable_set('@hash', { '_version' => '1.0', '_short_message' => 'message' })
+        @notifier.instance_variable_set('@hash', { 'version' => '1.0', 'short_message' => 'message' })
         datagrams = @notifier.__send__(:datagrams_from_hash)
         assert_equal 1, datagrams.count
+        assert_instance_of String, datagrams[0]
         assert_equal "\x78\x9c", 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 = { '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.instance_variable_set('@hash', hash)
         datagrams = @notifier.__send__(:datagrams_from_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
@@ -146,7 +164,7 @@ class TestNotifier < Test::Unit::TestCase
     context "level threshold" do
       setup do
         @notifier.level = GELF::WARN
-        @hash = { '_version' => '1.0', '_short_message' => 'message' }
+        @hash = { 'version' => '1.0', 'short_message' => 'message' }
       end
 
       ['debug', 'DEBUG', :debug].each do |l|
@@ -158,12 +176,12 @@ class TestNotifier < Test::Unit::TestCase
 
       should "not send notifications with level below threshold" do
         @sender.expects(:send_datagrams).never
-        @notifier.notify!(@hash.merge('_level' => GELF::DEBUG))
+        @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))
+        @notifier.notify!(@hash.merge('level' => GELF::WARN))
       end
     end
 
@@ -175,7 +193,7 @@ class TestNotifier < Test::Unit::TestCase
       should "not send datagrams" do
         @sender.expects(:send_datagrams).never
         @notifier.expects(:extract_hash).never
-        @notifier.notify!({ '_version' => '1.0', '_short_message' => 'message' })
+        @notifier.notify!({ 'version' => '1.0', 'short_message' => 'message' })
       end
 
       context "and enabled again" do
@@ -185,7 +203,7 @@ class TestNotifier < Test::Unit::TestCase
 
         should "send datagrams" do
           @sender.expects(:send_datagrams)
-          @notifier.notify!({ '_version' => '1.0', '_short_message' => 'message' })
+          @notifier.notify!({ 'version' => '1.0', 'short_message' => 'message' })
         end
       end
     end
@@ -194,13 +212,13 @@ class TestNotifier < Test::Unit::TestCase
       @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' })
+      @notifier.notify!({ 'version' => '1.0', 'short_message' => 'message' })
     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' })
+        @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
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gelf
 version: !ruby/object:Gem::Version 
-  hash: -1420906252
   prerelease: true
   segments: 
   - 1
   - 1
   - 0
-  - gamma1
-  version: 1.1.0.gamma1
+  - rc1
+  version: 1.1.0.rc1
 platform: ruby
 authors: 
 - Aleksey Palazhchenko
@@ -17,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-09 00:00:00 +03:00
+date: 2011-01-08 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -28,7 +27,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -42,7 +40,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -56,7 +53,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -107,7 +103,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -116,7 +111,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">"
     - !ruby/object:Gem::Version 
-      hash: 25
       segments: 
       - 1
       - 3
@@ -131,8 +125,8 @@ specification_version: 3
 summary: Library to send GELF messages to Graylog2 logging server.
 test_files: 
 - test/helper.rb
-- test/test_deprecations.rb
 - test/test_logger.rb
 - test/test_notifier.rb
-- test/test_ruby_sender.rb
 - test/test_severity.rb
+- test/test_ruby_sender.rb
+- test/test_deprecations.rb