gelf 1.0.2 → 1.1.0.beta1

data/.gitignore

@@ -1,5 +1,6 @@
 pkg/
 coverage/
 rdoc/
+tmp/
 
 .DS_Store

data/CHANGELOG

@@ -1,6 +1,21 @@
-1.0.1, 2010-11-29:
- - fix bug in chunking.
+1.1.0 (not yet released), 2010-11-xx:
+ + Notifier#default_options;
+ + severity (level) threshold;
+ + wrappers for GELF::Notifier#notify with severity:
+   - GELF::Notifier.debug
+   - GELF::Notifier.info
+   - GELF::Notifier.warn
+   - GELF::Notifier.error
+   - GELF::Notifier.fatal
+   - GELF::Notifier.unknown
+ + full compatibility with Ruby Logger and other loggers:
+   - GELF::Logger#fatal { "Argument 'foo' not given." }
+   - GELF::Logger#error "Argument #{ @foo } mismatch."
+   - GELF::Logger#info('initialize') { "Initializing..." }
+   - GELF::Logger#add(GELF::FATAL) { 'Fatal error!' }
+   - GELF::Logger#close
+   - GELF::Logger#level = GELF::INFO
 
 1.0.0, 2010-11-10:
- - initial stable version;
- - deprecated Gelf class is still there.
+ + initial stable version;
+ * deprecated Gelf class is still there.

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Lennart Koopmann
+Copyright (c) 2010 Lennart Koopmann, Aleksey Palazhchenko
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -17,4 +17,4 @@ Works with Ruby 1.8.7 and 1.9.2. 1.8.6 is not supported.
 
 == Copyright
 
-Copyright (c) 2010 Lennart Koopmann. See LICENSE for details.
+Copyright (c) 2010 Lennart Koopmann and Aleksey Palazhchenko. See LICENSE for details.

data/Rakefile

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'rake'
 
 begin
-  gem 'jeweler', '1.4.0'
+  gem 'jeweler', '~> 1.4.0' # https://github.com/technicalpickles/jeweler/issues/issue/150
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "gelf"
@@ -42,6 +42,11 @@ rescue LoadError
   end
 end
 
+begin
+  require 'metric_fu'
+rescue LoadError
+end
+
 task :test => :check_dependencies
 
 task :default => :test

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.1.0.beta1

data/benchmarks/notifier.rb

@@ -0,0 +1,32 @@
+#! /usr/bin/env ruby
+
+require 'benchmark'
+
+require 'rubygems'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'gelf'
+
+srand(1)
+RANDOM_DATA = ('A'..'z').to_a
+k1_message = (0..1024).map { RANDOM_DATA[rand(RANDOM_DATA.count)] }.join
+
+TARGET_HOST = 'localhost'
+TARGET_PORT = 12201
+DEFAULT_OPTIONS = { 'host' => 'localhost' }
+TIMES = 5000
+
+SHORT_HASH = { 'short_message' => 'message' }
+LONG_HASH = { 'short_message' => 'short message', 'long_message' => k1_message, 'user_id' => rand(10000)}
+
+
+notifier_lan = GELF::Notifier.new(TARGET_HOST, TARGET_PORT, 'LAN', DEFAULT_OPTIONS)
+notifier_wan = GELF::Notifier.new(TARGET_HOST, TARGET_PORT, 'WAN', DEFAULT_OPTIONS)
+
+puts "Sending #{TIMES} notifications..."
+tms = Benchmark.bmbm do |b|
+  b.report('lan, short data') { TIMES.times { notifier_lan.notify!(SHORT_HASH) } }
+  b.report('wan, short data') { TIMES.times { notifier_wan.notify!(SHORT_HASH) } }
+  b.report('lan,  long data') { TIMES.times { notifier_lan.notify!(LONG_HASH) } }
+  b.report('wan,  long data') { TIMES.times { notifier_wan.notify!(LONG_HASH) } }
+end

data/gelf.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gelf}
-  s.version = "1.0.2"
+  s.version = "1.1.0.beta1"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alexey Palazhchenko", "Lennart Koopmann"]
-  s.date = %q{2010-11-29}
+  s.date = %q{2010-11-25}
   s.description = %q{Suports plain-text, GELF messages and exceptions.}
   s.email = %q{lennart@socketfeed.com}
   s.extra_rdoc_files = [
@@ -23,13 +23,21 @@ Gem::Specification.new do |s|
      "README.rdoc",
      "Rakefile",
      "VERSION",
+     "benchmarks/notifier.rb",
      "gelf.gemspec",
      "lib/gelf.rb",
      "lib/gelf/deprecations.rb",
+     "lib/gelf/em_sender.rb",
+     "lib/gelf/logger.rb",
      "lib/gelf/notifier.rb",
+     "lib/gelf/ruby_sender.rb",
+     "lib/gelf/severity.rb",
      "test/helper.rb",
      "test/test_deprecations.rb",
-     "test/test_notifier.rb"
+     "test/test_logger.rb",
+     "test/test_notifier.rb",
+     "test/test_ruby_sender.rb",
+     "test/test_severity.rb"
   ]
   s.homepage = %q{http://github.com/Graylog2/gelf-rb}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -39,7 +47,10 @@ Gem::Specification.new do |s|
   s.test_files = [
     "test/helper.rb",
      "test/test_deprecations.rb",
-     "test/test_notifier.rb"
+     "test/test_logger.rb",
+     "test/test_notifier.rb",
+     "test/test_ruby_sender.rb",
+     "test/test_severity.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/gelf.rb

@@ -3,5 +3,8 @@ require 'socket'
 require 'zlib'
 require 'digest/sha2'
 
+require 'gelf/severity'
+require 'gelf/ruby_sender'
 require 'gelf/notifier'
+require 'gelf/logger'
 require 'gelf/deprecations'

data/lib/gelf/deprecations.rb

@@ -19,15 +19,15 @@ class Gelf
     @notifier.notify(@message)
   end
 
-  [:short_message, :full_message, :level, :host, :line, :file].each do |a|
-    define_method a do
-      deprecate("GELF::Message##{a}")
-      @message[a]
+  [:short_message, :full_message, :level, :host, :line, :file].each do |attribute|
+    define_method attribute do
+      deprecate("GELF::Message##{attribute}")
+      @message[attribute]
     end
 
-    define_method "#{a}=" do |value|
-      deprecate("GELF::Message##{a} = value")
-      @message[a] = value
+    define_method "#{attribute}=" do |value|
+      deprecate("GELF::Message##{attribute} = value")
+      @message[attribute] = value
     end
   end
 

data/lib/gelf/em_sender.rb

@@ -0,0 +1,10 @@
+module GELF
+  # Sender for EventMachine.
+  class EMSender
+    def initialize(host, port)
+    end
+
+    def send_datagrams(datagrams)
+    end
+  end
+end

data/lib/gelf/logger.rb

@@ -0,0 +1,50 @@
+module GELF
+  # Methods for compatibility with Ruby Logger.
+  module LoggerCompatibility
+    # Does nothing.
+    def close
+    end
+
+    # Use it like Logger#add… or better not to use at all.
+    def add(level, *args)
+      raise ArgumentError.new('Wrong arguments.') unless (0..2).include?(args.count)
+
+      # Ruby Logger's author is a maniac.
+      message, facility = if args.count == 2
+                            [args[0], args[1]]
+                          elsif args.count == 0
+                            [yield, nil]
+                          elsif block_given?
+                            [yield, args[0]]
+                          else
+                            [args[0], nil]
+                          end
+
+      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
+
+    GELF::Levels.constants.each do |const|
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{const.downcase}(*args)                  # def debug(*args)
+          args.unshift(yield) if block_given?         #   args.unshift(yield) if block_given?
+          add(GELF::#{const}, *args)                  #   add(GELF::DEBUG, *args)
+        end                                           # end
+
+        def #{const.downcase}?                        # def debug?
+          GELF::#{const} >= level                     #   GELF::DEBUG >= level
+        end                                           # end
+      EOT
+    end
+
+    def <<(message)
+      notify('short_message' => message, 'level' => GELF::UNKNOWN)
+    end
+  end
+
+  # Graylog2 notifier, compatible with Ruby Logger.
+  class Logger < Notifier
+    include LoggerCompatibility
+  end
+end

data/lib/gelf/notifier.rb

@@ -1,117 +1,168 @@
 module GELF
+  # Graylog2 notifier.
   class Notifier
-    @@id = 0
+    @last_chunk_id = 0
+    class << self
+      attr_accessor :last_chunk_id
+    end
 
-    attr_accessor :host, :port
-    attr_reader :max_chunk_size
+    attr_accessor :host, :port, :default_options
+    attr_reader :max_chunk_size, :level
 
     # +host+ and +port+ are host/ip and port of graylog2-server.
-    def initialize(host = 'localhost', port = 12201, max_size = 'WAN')
-      @host, @port, self.max_chunk_size = host, port, max_size
+    # +max_size+ is passed to max_chunk_size=.
+    # +default_options+ is used in notify!
+    def initialize(host = 'localhost', port = 12201, max_size = 'WAN', default_options = {})
+      self.level = GELF::DEBUG
+
+      self.host, self.port, self.max_chunk_size = host, port, max_size
+
+      @default_options = {}
+      self.default_options = default_options
+      self.default_options['host'] ||= Socket.gethostname
+      self.default_options['level'] ||= GELF::DEBUG
+      self.default_options['facility'] ||= 'gelf-rb'
+
+      @sender = RubySender.new(host, port)
     end
 
     # +size+ may be a number of bytes, 'WAN' (1420 bytes) or 'LAN' (8154).
     # Default (safe) value is 'WAN'.
     def max_chunk_size=(size)
-      s = size.to_s.downcase
-      if s == 'wan'
+      size_s = size.to_s.downcase
+      if size_s == 'wan'
         @max_chunk_size = 1420
-      elsif s == 'lan'
+      elsif size_s == 'lan'
         @max_chunk_size = 8154
       else
         @max_chunk_size = size.to_int
       end
     end
 
+    def level=(new_level)
+      @level = new_level
+    end
+
     # Same as notify!, but rescues all exceptions (including +ArgumentError+)
     # and sends them instead.
     def notify(*args)
-      notify!(*args)
-    rescue Exception => e
-      notify!(e)
+      notify_with_level(nil, *args)
     end
 
     # Sends message to Graylog2 server.
     # +args+ can be:
-    # - hash-like object (any object which responds to +to_hash+, including +Hash+ instance)
+    # - hash-like object (any object which responds to +to_hash+, including +Hash+ instance):
     #    notify!(:short_message => 'All your rebase are belong to us', :user => 'AlekSi')
-    # - exception with optional hash-like object
+    # - exception with optional hash-like object:
     #    notify!(SecurityError.new('ALARM!'), :trespasser => 'AlekSi')
-    # - string-like object (anything which responds to +to_s+) with optional hash-like object
+    # - string-like object (anything which responds to +to_s+) with optional hash-like object:
     #    notify!('Plain olde text message', :scribe => 'AlekSi')
+    # Resulted fields are merged with +default_options+, the latter will never overwrite the former.
     # This method will raise +ArgumentError+ if arguments are wrong. Consider using notify instead.
     def notify!(*args)
-      do_notify(extract_hash(*args))
+      notify_with_level!(nil, *args)
+    end
+
+    GELF::Levels.constants.each do |const|
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{const.downcase}(*args)                          # def debug(*args)
+          notify_with_level(GELF::#{const}, *args)            #   notify_with_level(GELF::DEBUG, *args)
+        end                                                   # end
+      EOT
     end
 
   private
-    def extract_hash(object_or_exception, args = {})
-      primary_data = if object_or_exception.respond_to?(:to_hash)
-                       object_or_exception.to_hash
-                     elsif object_or_exception.is_a?(Exception)
-                       bt = object_or_exception.backtrace || ["Backtrace is not available."]
-                       { 'short_message' => "#{object_or_exception.class}: #{object_or_exception.message}",
-                         'full_message' => "Backtrace:\n" + bt.join("\n") }
+    def notify_with_level(message_level, *args)
+      notify_with_level!(message_level, *args)
+    rescue Exception => exception
+      notify_with_level!(GELF::UNKNOWN, exception)
+    end
+
+    def notify_with_level!(message_level, *args)
+      extract_hash(*args)
+      @hash['level'] = message_level unless message_level.nil?
+      if @hash['level'] >= level
+        @sender.send_datagrams(datagrams_from_hash)
+      end
+    end
+
+    def extract_hash(object = nil, args = {})
+      primary_data = if object.respond_to?(:to_hash)
+                       object.to_hash
+                     elsif object.is_a?(Exception)
+                       args['level'] ||= GELF::ERROR
+                       self.class.extract_hash_from_exception(object)
                      else
-                       { 'short_message' => object_or_exception.to_s }
+                       args['level'] ||= GELF::INFO
+                       { 'short_message' => object.to_s }
                      end
 
-      hash = args.merge(primary_data)
-
-      hash.keys.each do |key|
-        value, key_s = hash.delete(key), key.to_s
-        raise ArgumentError.new("Both #{key.inspect} and #{key_s} are present.") if hash.has_key?(key_s)
-        hash[key_s] = value
-      end
+      @hash = default_options.merge(args.merge(primary_data))
+      stringify_hash_keys
+      convert_hoptoad_keys_to_graylog2
+      check_presence_of_mandatory_attributes
+      @hash
+    end
 
-      hash['host'] ||= @this_host || detect_this_host
+    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") }
+    end
 
-      # for compatibility with HoptoadNotifier
-      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')
+    # Converts Hoptoad-specific keys in +@hash+ to Graylog2-specific.
+    def convert_hoptoad_keys_to_graylog2
+      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')
         end
       end
+    end
 
-      %w(short_message host).each do |a|
-        if hash[a].to_s.empty?
-          raise ArgumentError.new("Attributes short_message and host must be set.")
+    def check_presence_of_mandatory_attributes
+      %w(short_message host).each do |attribute|
+        if @hash[attribute].to_s.empty?
+          raise ArgumentError.new("Options short_message and host must be set.")
         end
       end
-
-      hash
     end
 
-    def do_notify(hash)
-      data = Zlib::Deflate.deflate(hash.to_json).bytes
-      sock = UDPSocket.open
+    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
       datagrams = []
 
       # Maximum total size is 8192 byte for UDP datagram. Split to chunks if bigger. (GELFv2 supports chunking)
       if data.count > @max_chunk_size
-        @@id += 1
-        msg_id = Digest::SHA256.digest("#{Time.now.to_f}-#{@@id}")
-        i, count = 0, (data.count / 1.0 / @max_chunk_size).ceil
+        id = self.class.last_chunk_id += 1
+        msg_id = Digest::SHA256.digest("#{Time.now.to_f}-#{id}")
+        num, count = 0, (data.count.to_f / @max_chunk_size).ceil
         data.each_slice(@max_chunk_size) do |slice|
-          datagrams << chunk_data(slice, msg_id, i, count)
-          i += 1
+          datagrams << self.class.chunk_data(slice, msg_id, num, count)
+          num += 1
         end
       else
         datagrams = [data.map(&:chr).join]
       end
 
-      datagrams.each { |d| sock.send(d, 0, @host, @port) }
       datagrams
     end
 
-    def chunk_data(data, msg_id, sequence_number, sequence_count)
-      return "\036\017" + msg_id + [sequence_number, sequence_count, *data].pack('nnC*')
+    def self.chunk_data(data, msg_id, num, count)
+      # [30, 15].pack('CC') => "\036\017"
+      return "\036\017" + msg_id + [num, count].pack('nn') + data.map(&:chr).join
     end
 
-    def detect_this_host
-      @this_host = Socket.gethostname
+    def stringify_hash_keys
+      @hash.keys.each do |key|
+        value, key_s = @hash.delete(key), key.to_s
+        raise ArgumentError.new("Both #{key.inspect} and #{key_s} are present.") if @hash.has_key?(key_s)
+        @hash[key_s] = value
+      end
     end
   end
 end

data/lib/gelf/ruby_sender.rb

@@ -0,0 +1,15 @@
+module GELF
+  # Plain Ruby sender.
+  class RubySender
+    def initialize(host, port)
+      @host, @port = host, port
+      @socket = UDPSocket.open
+    end
+
+    def send_datagrams(datagrams)
+      datagrams.each do |datagram|
+        @socket.send(datagram, 0, @host, @port)
+      end
+    end
+  end
+end

data/lib/gelf/severity.rb

@@ -0,0 +1,28 @@
+module GELF
+  # There are two things you should know about log leves/severity:
+  #  - syslog defines levels from 0 (Emergency) to 7 (Debug).
+  #    0 (Emergency) and 1 (Alert) levels are reserved for OS kernel.
+  #  - Ruby default Logger defines levels from 0 (DEBUG) to 4 (FATAL) and 5 (UNKNOWN).
+  #    Note that order is inverted.
+  # For compatibility we define our constants as Ruby Logger, and convert values before
+  # generating GELF message.
+
+  module Levels
+    DEBUG   = 0
+    INFO    = 1
+    WARN    = 2
+    ERROR   = 3
+    FATAL   = 4
+    UNKNOWN = 5
+  end
+
+  include Levels
+
+  # Maps Ruby Logger levels to syslog levels as SyslogLogger and syslogger gems.
+  LEVELS_MAPPING = {DEBUG   => 7, # Debug
+                    INFO    => 6, # Info
+                    WARN    => 5, # Notice
+                    ERROR   => 4, # Warning
+                    FATAL   => 3, # Error
+                    UNKNOWN => 1} # Alert – shouldn't be used
+end

data/test/helper.rb

@@ -3,6 +3,11 @@ require 'test/unit'
 require 'shoulda'
 require 'mocha'
 
+begin
+  require 'ruby-debug'
+rescue LoadError
+end
+
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'gelf'

data/test/test_logger.rb

@@ -0,0 +1,135 @@
+require 'helper'
+
+class TestLogger < Test::Unit::TestCase
+  context "with notifier with mocked sender" do
+    setup do
+      Socket.stubs(:gethostname).returns('stubbed_hostname')
+      @notifier = GELF::Logger.new('host', 12345)
+      @sender = mock
+      @notifier.instance_variable_set('@sender', @sender)
+    end
+
+    should "respond to #close" do
+      assert @notifier.respond_to?(:close)
+    end
+
+    context "#add" do
+      # logger.add(Logger::INFO, 'Message')
+      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'
+        end
+        @notifier.add(GELF::INFO, 'Message')
+      end
+
+      # logger.add(Logger::INFO, RuntimeError.new('Boom!'))
+      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/
+        end
+        @notifier.add(GELF::INFO, RuntimeError.new('Boom!'))
+      end
+
+      # logger.add(Logger::INFO) { 'Message' }
+      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'
+        end
+        @notifier.add(GELF::INFO) { 'Message' }
+      end
+
+      # logger.add(Logger::INFO) { RuntimeError.new('Boom!') }
+      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/
+        end
+        @notifier.add(GELF::INFO) { RuntimeError.new('Boom!') }
+      end
+
+      # logger.add(Logger::INFO, 'Message', 'Facility')
+      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'
+        end
+        @notifier.add(GELF::INFO, 'Message', 'Facility')
+      end
+
+      # logger.add(Logger::INFO, RuntimeError.new('Boom!'), 'Facility')
+      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'
+        end
+        @notifier.add(GELF::INFO, RuntimeError.new('Boom!'), 'Facility')
+      end
+
+      # logger.add(Logger::INFO, 'Facility') { 'Message' }
+      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'
+        end
+        @notifier.add(GELF::INFO, 'Facility') { 'Message' }
+      end
+
+      # logger.add(Logger::INFO, 'Facility') { RuntimeError.new('Boom!') }
+      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'
+        end
+        @notifier.add(GELF::INFO, 'Facility') { RuntimeError.new('Boom!') }
+      end
+    end
+
+    GELF::Levels.constants.each do |const|
+      # logger.error "Argument #{ @foo } mismatch."
+      should "call notify with level #{const} from method name and message from parameter" do
+        @notifier.expects(:add).with(GELF.const_get(const), 'message')
+        @notifier.__send__(const.downcase, 'message')
+      end
+
+      # logger.fatal { "Argument 'foo' not given." }
+      should "call notify with level #{const} from method name and message from block" do
+        @notifier.expects(:add).with(GELF.const_get(const), 'message')
+        @notifier.__send__(const.downcase) { 'message' }
+      end
+
+      # logger.info('initialize') { "Initializing..." }
+      should "call notify with level #{const} from method name, facility from parameter and message from block" do
+        @notifier.expects(:add).with(GELF.const_get(const), 'message', 'facility')
+        @notifier.__send__(const.downcase, 'facility') { 'message' }
+      end
+
+      should "respond to #{const.downcase}?" do
+        @notifier.level = GELF.const_get(const) - 1
+        assert @notifier.__send__(const.to_s.downcase + '?')
+        @notifier.level = GELF.const_get(const)
+        assert @notifier.__send__(const.to_s.downcase + '?')
+        @notifier.level = GELF.const_get(const) + 1
+        assert !@notifier.__send__(const.to_s.downcase + '?')
+      end
+    end
+
+    should "support Notifier#<<" do
+      @notifier.expects(:notify_with_level!).with do |nil_, hash|
+        hash['short_message'] == "Message" &&
+        hash['level'] == GELF::UNKNOWN
+      end
+      @notifier << "Message"
+    end
+  end
+end

data/test/test_notifier.rb

@@ -1,24 +1,33 @@
 require 'helper'
 
-HASH = {'short_message' => 'message', 'host' => 'localhost'}
+HASH = {'short_message' => 'message', 'host' => 'somehost', 'level' => GELF::WARN, 'facility' => 'test'}
 
 RANDOM_DATA = ('A'..'Z').to_a
 
 class TestNotifier < Test::Unit::TestCase
-  should "allow access to host, port and max_chunk_size" do
-    notifier = GELF::Notifier.new
-    assert_equal ['localhost', 12201, 1420], [notifier.host, notifier.port, notifier.max_chunk_size]
-    notifier.host, notifier.port, notifier.max_chunk_size = 'graylog2.org', 7777, :lan
-    assert_equal ['graylog2.org', 7777, 8154], [notifier.host, notifier.port, notifier.max_chunk_size]
+  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.host, n.port, n.max_chunk_size]
+    assert_equal({'level' => 0, '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'}
+    assert_equal ['graylog2.org', 7777, 8154], [n.host, n.port, 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" do
+  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 number of arguments" do
+      should "check arguments" do
         assert_raise(ArgumentError) { @notifier.__send__(:extract_hash) }
         assert_raise(ArgumentError) { @notifier.__send__(:extract_hash, 1, 2, 3) }
       end
@@ -39,6 +48,7 @@ class TestNotifier < Test::Unit::TestCase
         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
@@ -48,18 +58,23 @@ class TestNotifier < Test::Unit::TestCase
       end
 
       should "work with exception and hash" do
-        e, h = RuntimeError.new('message'), {'param' => 1, '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 1, hash['param']
       end
 
       should "work with plain text" do
-        assert_equal 'message', @notifier.__send__(:extract_hash, 'message')['short_message']
+        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
-        assert_equal HASH, @notifier.__send__(:extract_hash, 'message', 'host' => 'localhost')
+        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
@@ -72,6 +87,13 @@ class TestNotifier < Test::Unit::TestCase
         assert_raise(ArgumentError) { @notifier.__send__(:extract_hash, :short_message => :message1, 'short_message' => 'message2') }
       end
 
+      should "use default_options" do
+        @notifier.default_options = {:file => 'somefile.rb', 'short_message' => 'will be hidden by explicit argument'}
+        hash = @notifier.__send__(:extract_hash, HASH)
+        assert_equal 'somefile.rb', hash['file']
+        assert_not_equal 'will be hidden by explicit argument', 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')
@@ -79,41 +101,52 @@ class TestNotifier < Test::Unit::TestCase
       end
     end
 
-    should "detect and cache host" do
-      Socket.expects(:gethostname).once.returns("localhost")
-      @notifier.expects(:do_notify).twice
-      2.times { @notifier.notify!('short_message' => 'message') }
+    context "datagrams_from_hash" do
+      should "not split short data" do
+        @notifier.instance_variable_set('@hash', HASH)
+        datagrams = @notifier.__send__(:datagrams_from_hash)
+        assert_equal 1, datagrams.count
+        assert_equal "\170\234", datagrams[0][0..1]
+      end
+
+      should "split long data" do
+        srand(1) # for stable tests
+        hash = 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
+        assert_equal "\036\017", datagrams[0][0..1]
+        assert_equal "\036\017", datagrams[1][0..1]
+      end
     end
 
-    context "datagrams" do
-      should "not split short datagram" do
-        UDPSocket.any_instance.expects(:send).once
-        @notifier.notify!(HASH)
+    context "level threshold" do
+      setup do
+        @notifier.level = GELF::WARN
       end
 
-      should "split long datagram" do
-        srand(1) # for stable tests
-        UDPSocket.any_instance.expects(:send).twice
-        @notifier.notify!(HASH.merge('something' => (0..3000).map { RANDOM_DATA[rand(RANDOM_DATA.count)] }.join)) # or it will be compressed too good
+      should "not send notifications with level below threshold" do
+        @sender.expects(:send_datagrams).never
+        @notifier.notify!(HASH.merge('level' => GELF::DEBUG))
       end
 
-      should "send correct short datagram" do
-        UDPSocket.any_instance.expects(:send).with do |data, flags, host, port|
-          host == @notifier.host &&
-          port == @notifier.port &&
-          data[0..1] == "\170\234"
-        end
-        @notifier.notify!(HASH)
+      should "not notifications with level equal or above threshold" do
+        @sender.expects(:send_datagrams).once
+        @notifier.notify!(HASH.merge('level' => GELF::WARN))
       end
+    end
 
-      should "send correct long datagrams" do
-        UDPSocket.any_instance.expects(:send).twice.with do |data, flags, host, port|
-          host == @notifier.host &&
-          port == @notifier.port &&
-          data[0..1] == "\036\017"
-        end
-        srand(1) # for stable tests
-        @notifier.notify!(HASH.merge('something' => (0..3000).map { RANDOM_DATA[rand(RANDOM_DATA.count)] }.join)) # or it will be compressed too good
+    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!(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), HASH)
+        @notifier.__send__(const.downcase, HASH)
       end
     end
 
@@ -122,26 +155,9 @@ class TestNotifier < Test::Unit::TestCase
     end
 
     should "rescue from invalid invocation of #notify" do
-      @notifier.expects(:notify!).with(instance_of(Hash)).raises(ArgumentError)
-      @notifier.expects(:notify!).with(instance_of(ArgumentError))
+      @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
-
-    should "chunk data" do
-      UDPSocket.any_instance.stubs(:send)
-      srand(1) # for stable tests
-      data = (0..3000).map { RANDOM_DATA[rand(RANDOM_DATA.count)] }.join
-      datagrams = @notifier.__send__(:do_notify, {'short_message' => data, 'host' => 'localhost'})
-      assert_equal 2, datagrams.count
-      datagrams.each_index do |i|
-        datagram = datagrams[i]
-        assert datagram[0..1] == "\x1e\x0f"
-        # datagram[2..33] is a message id
-        assert_equal 0, datagram[34].ord
-        assert_equal i, datagram[35].ord
-        assert_equal 0, datagram[36].ord
-        assert_equal datagrams.count, datagram[37].ord
-      end
-    end
   end
 end

data/test/test_ruby_sender.rb

@@ -0,0 +1,21 @@
+require 'helper'
+
+class TestRubySender < Test::Unit::TestCase
+  context "with ruby sender" do
+    setup do
+      @host, @port = 'localhost', 12201
+      @sender = GELF::RubySender.new('localhost', 12201)
+      @datagrams = %w(d1 d2 d3)
+    end
+
+    context "send_datagrams" do
+      setup do
+        @sender.send_datagrams(@datagrams)
+      end
+
+      before_should "be called with 3 times correct parameters" do
+        UDPSocket.any_instance.expects(:send).times(3).with(instance_of(String), 0, @host, @port).returns(@datagrams)
+      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" do
+    GELF::LEVELS_MAPPING.each do |ruby_level, syslog_level|
+      assert_not_equal syslog_level, ruby_level
+    end
+  end
+end

metadata

@@ -1,12 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: gelf
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  hash: -1848230059
+  prerelease: true
   segments: 
   - 1
+  - 1
   - 0
-  - 2
-  version: 1.0.2
+  - beta1
+  version: 1.1.0.beta1
 platform: ruby
 authors: 
 - Alexey Palazhchenko
@@ -15,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-29 00:00:00 +03:00
+date: 2010-11-25 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,6 +28,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -39,6 +42,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -52,6 +56,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -73,13 +78,21 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- benchmarks/notifier.rb
 - gelf.gemspec
 - lib/gelf.rb
 - lib/gelf/deprecations.rb
+- lib/gelf/em_sender.rb
+- lib/gelf/logger.rb
 - lib/gelf/notifier.rb
+- lib/gelf/ruby_sender.rb
+- lib/gelf/severity.rb
 - test/helper.rb
 - test/test_deprecations.rb
+- test/test_logger.rb
 - test/test_notifier.rb
+- test/test_ruby_sender.rb
+- test/test_severity.rb
 has_rdoc: true
 homepage: http://github.com/Graylog2/gelf-rb
 licenses: []
@@ -94,17 +107,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 
@@ -115,4 +132,7 @@ 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