gelf 1.3.2 → 1.4.0.beta1

data/VERSION

@@ -1 +1 @@
-1.3.2
+1.4.0.beta1

data/benchmarks/incremental.rb

@@ -0,0 +1,17 @@
+#! /usr/bin/env ruby
+
+require 'rubygems'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'gelf'
+
+TARGET_HOST = 'localhost'
+TARGET_PORT = 5140
+RANGE = 35000...36000
+
+n = GELF::Notifier.new(TARGET_HOST, TARGET_PORT, 'WAN')
+RANGE.each do |size|
+  n.notify!('a' * size)
+  puts size if (size % 100) == 0
+  sleep 0.01
+end

data/benchmarks/notifier.rb

@@ -1,13 +1,15 @@
 #! /usr/bin/env ruby
 
-puts "Loading..."
-
 require 'benchmark'
+require 'thread'
 require 'rubygems'
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'gelf'
 
+Thread.abort_on_exception = true
+
+puts "Running on #{RUBY_DESCRIPTION}"
 puts "Generating random data..."
 srand(1)
 RANDOM_DATA = ('A'..'z').to_a
@@ -16,11 +18,21 @@ k3_message = (1..3*1024).map { RANDOM_DATA[rand(RANDOM_DATA.count)] }.join
 TARGET_HOST = 'localhost'
 TARGET_PORT = 12201
 DEFAULT_OPTIONS = { '_host' => 'localhost' }
-TIMES = 5000
+MESSAGES_COUNT = 5000
+THREADS_COUNT = 50
 
 SHORT_HASH = { 'short_message' => 'message' }
 LONG_HASH  = { 'short_message' => 'message', 'long_message' => k3_message }
 
+def notify(n, hash)
+  threads = []
+  THREADS_COUNT.times do
+    threads << Thread.new do
+      (MESSAGES_COUNT / THREADS_COUNT).times { n.notify!(hash) }
+    end
+  end
+  threads.each { |t| t.join }
+end
 
 notifier_lan = GELF::Notifier.new(TARGET_HOST, TARGET_PORT, 'LAN', DEFAULT_OPTIONS)
 notifier_wan = GELF::Notifier.new(TARGET_HOST, TARGET_PORT, 'WAN', DEFAULT_OPTIONS)
@@ -29,11 +41,11 @@ notifier_wan = GELF::Notifier.new(TARGET_HOST, TARGET_PORT, 'WAN', DEFAULT_OPTIO
 notifier_lan.notify!(LONG_HASH)
 sleep(5)
 
-puts "Sending #{TIMES} notifications...\n"
+puts "Sending #{MESSAGES_COUNT} notifications...\n"
 tms = Benchmark.bm(25) do |b|
-  b.report('lan, short data, 1 chunk ') { TIMES.times { notifier_lan.notify!(SHORT_HASH) } }
+  b.report('lan, short data, 1 chunk ') { notify(notifier_lan, SHORT_HASH) }
   sleep(5)
-  b.report('lan,  long data, 1 chunk ') { TIMES.times { notifier_lan.notify!(LONG_HASH) } }
+  b.report('lan,  long data, 1 chunk ') { notify(notifier_lan, LONG_HASH) }
   sleep(5)
-  b.report('wan,  long data, 2 chunks') { TIMES.times { notifier_wan.notify!(LONG_HASH) } }
+  b.report('wan,  long data, 2 chunks') { notify(notifier_wan, LONG_HASH) }
 end

data/gelf.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "gelf"
-  s.version = "1.3.2"
+  s.version = "1.4.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 = "2011-12-02"
+  s.date = "2012-01-17"
   s.description = "Library to send GELF messages to Graylog2 logging server. Supports plain-text, GELF messages and exceptions."
   s.email = "alexey.palazhchenko@gmail.com"
   s.extra_rdoc_files = [
@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
     "README.rdoc",
     "Rakefile",
     "VERSION",
+    "benchmarks/incremental.rb",
     "benchmarks/notifier.rb",
     "gelf.gemspec",
     "lib/gelf.rb",
@@ -39,7 +40,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/Graylog2/gelf-rb"
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.11"
+  s.rubygems_version = "1.8.15"
   s.summary = "Library to send GELF messages to Graylog2 logging server."
 
   if s.respond_to? :specification_version then

data/lib/gelf.rb

@@ -2,6 +2,7 @@ require 'json'
 require 'socket'
 require 'zlib'
 require 'digest/md5'
+require 'thread'
 
 module GELF
   SPEC_VERSION = '1.0'

data/lib/gelf/logger.rb

@@ -5,7 +5,7 @@ module GELF
     def close
     end
 
-    # Use it like Logger#add... or better not to use at all.
+    # Use it like Logger#add... or better not use directly at all.
     def add(level, *args)
       raise ArgumentError.new('Wrong arguments.') unless (0..2).include?(args.count)
 
@@ -50,6 +50,5 @@ module GELF
   #     config.colorize_logging = false
   class Logger < Notifier
     include LoggerCompatibility
-    @last_chunk_id = 0
   end
 end

data/lib/gelf/notifier.rb

@@ -1,11 +1,6 @@
 module GELF
   # Graylog2 notifier.
   class Notifier
-    @last_chunk_id = 0
-    class << self
-      attr_accessor :last_chunk_id
-    end
-
     attr_accessor :enabled, :collect_file_and_line, :rescue_network_errors
     attr_reader :max_chunk_size, :level, :default_options, :level_mapping
 
@@ -137,14 +132,16 @@ 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
-        @sender.send_datagrams(datagrams_from_hash)
+      hash = extract_hash(*args)
+      hash['level'] = message_level unless message_level.nil?
+      if hash['level'] >= level
+        @sender.send_datagrams(datagrams_from_hash(hash))
       end
     end
 
     def extract_hash(object = nil, args = {})
+      args = self.class.stringify_keys(args)
+
       primary_data = if object.respond_to?(:to_hash)
                        object.to_hash
                      elsif object.is_a?(Exception)
@@ -155,61 +152,94 @@ module GELF
                        { 'short_message' => object.to_s }
                      end
 
-      @hash = default_options.merge(self.class.stringify_keys(args.merge(primary_data)))
-      convert_hoptoad_keys_to_graylog2
-      set_file_and_line if @collect_file_and_line
-      set_timestamp
-      check_presence_of_mandatory_attributes
-      @hash
+      hash = self.class.stringify_keys(primary_data)
+      hash = default_options.merge(args.merge(hash))
+      hash = convert_airbrake_keys_to_graylog2(hash)
+      hash = set_file_and_line(hash)
+      hash = set_timestamp(hash)
+      check_presence_of_mandatory_attributes(hash)
+      hash
     end
 
+    CALLER_REGEXP = /^(.*):(\d+).*/
+
     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") }
+      error_class = exception.class.name
+      error_message = exception.message
+
+      # always collect file and line there (ignore @collect_file_and_line)
+      # since we already know them, no need to call `caller`
+      file, line = nil, nil
+      bt = exception.backtrace
+      if bt
+        match = CALLER_REGEXP.match(bt[0])
+        if match
+          file = match[1]
+          line = match[2].to_i
+        end
+      else
+        bt = ["Backtrace is not available."]
+      end
+
+      { 'short_message' => "#{error_class}: #{error_message}", 'full_message' => "Backtrace:\n" + bt.join("\n"),
+        'error_class' => error_class, 'error_message' => error_message,
+        'file' => file, 'line' => line }
     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.has_key?('error_class') && @hash.has_key?('error_message')
-          @hash['short_message'] = @hash.delete('error_class') + ': ' + @hash.delete('error_message')
+    # Converts Airbrake-specific keys in +hash+ to Graylog2-specific.
+    def convert_airbrake_keys_to_graylog2(hash)
+      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']
         end
       end
+      hash
     end
 
-    CALLER_REGEXP = /^(.*):(\d+).*/
     LIB_GELF_PATTERN = File.join('lib', 'gelf')
 
-    def set_file_and_line
-      stack = caller
-      begin
-        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
+    def set_file_and_line(hash)
+      return hash unless hash['file'].nil? || hash['line'].nil?
+
+      if @collect_file_and_line
+        stack = caller
+        begin
+          frame = stack.shift
+        end while frame.include?(LIB_GELF_PATTERN)
+
+        match = CALLER_REGEXP.match(frame)
+        if match
+          hash['file'] = match[1]
+          hash['line'] = match[2].to_i
+        else
+          hash['file'] = 'unknown'
+          hash['line'] = -1
+        end
+      end
+
+      hash
     end
 
-    def set_timestamp
-      @hash['timestamp'] = Time.now.utc.to_f if @hash['timestamp'].nil?
+    def set_timestamp(hash)
+      hash['timestamp'] ||= Time.now.utc.to_f
+      hash
     end
 
-    def check_presence_of_mandatory_attributes
+    def check_presence_of_mandatory_attributes(hash)
       %w(version short_message host).each do |attribute|
-        if @hash[attribute].to_s.empty?
+        if hash[attribute].to_s.empty?
           raise ArgumentError.new("#{attribute} is missing. Options version, short_message and host must be set.")
         end
       end
     end
 
-    def datagrams_from_hash
-      data = serialize_hash
+    def datagrams_from_hash(hash)
+      data = serialize_hash(hash)
       datagrams = []
 
       # Maximum total size is 8192 byte for UDP datagram. Split to chunks if bigger. (GELF v1.0 supports chunking)
       if data.count > @max_chunk_size
-        id = self.class.last_chunk_id += 1
-        msg_id = Digest::MD5.digest("#{Time.now.to_f}-#{id}")[0, 8]
+        msg_id = Digest::MD5.digest("#{Time.now.to_f}-#{hash.object_id}")[0, 8]
         num, count = 0, (data.count.to_f / @max_chunk_size).ceil
         data.each_slice(@max_chunk_size) do |slice|
           datagrams << "\x1e\x0f" + msg_id + [num, count, *slice].pack('C*')
@@ -222,12 +252,12 @@ module GELF
       datagrams
     end
 
-    def serialize_hash
-      raise ArgumentError.new("Hash is empty.") if @hash.nil? || @hash.empty?
+    def serialize_hash(hash)
+      raise ArgumentError.new("Hash is empty.") if hash.nil? || hash.empty?
 
-      @hash['level'] = @level_mapping[@hash['level']]
+      hash['level'] = @level_mapping[hash['level']]
 
-      Zlib::Deflate.deflate(@hash.to_json).bytes
+      Zlib::Deflate.deflate(hash.to_json).bytes
     end
 
     def self.stringify_keys(hash)

data/lib/gelf/ruby_sender.rb

@@ -1,17 +1,32 @@
 module GELF
   # Plain Ruby UDP sender.
   class RubyUdpSender
-    attr_accessor :addresses
-
-    def initialize(addresses)
-      @addresses = addresses
-      @i = 0
+    def initialize(addrs)
+      @mutex = ::Mutex.new
       @socket = UDPSocket.open
+      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF, 65507)  # 65535 - 20 (ip header) - 8 (udp header)
+      self.addresses = addrs
+    end
+
+    def addresses
+      @mutex.synchronize do
+        @i = 0
+        @addresses
+      end
+    end
+
+    def addresses=(addrs)
+      @mutex.synchronize do
+        @i = 0
+        @addresses = addrs
+      end
     end
 
     def send_datagrams(datagrams)
+      # not thread-safe, but we don't care if round-robin algo fails sometimes
       host, port = @addresses[@i]
       @i = (@i + 1) % @addresses.length
+
       datagrams.each do |datagram|
         @socket.send(datagram, 0, host, port)
       end

data/test/test_notifier.rb

@@ -52,20 +52,30 @@ class TestNotifier < Test::Unit::TestCase
         e.set_backtrace(caller)
         hash = @notifier.__send__(:extract_hash, e)
         assert_equal 'RuntimeError: message', hash['short_message']
+        assert_equal 'RuntimeError', hash['error_class']
+        assert_equal 'message', hash['error_message']
+        assert_match /shoulda/, hash['file']
+        assert       hash['line'] > 300  # 382 in shoulda 2.11.3
         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)
+        hash, line = @notifier.__send__(:extract_hash, e), __LINE__
+        assert_equal __FILE__, hash['file']
+        assert_equal line, hash['line']
         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)
+        hash, line = @notifier.__send__(:extract_hash, e, h), __LINE__
         assert_equal 'RuntimeError: message', hash['short_message']
+        assert_equal 'RuntimeError', hash['error_class']
+        assert_equal 'message', hash['error_message']
+        assert_equal __FILE__, hash['file']
+        assert_equal line, hash['line']
         assert_equal GELF::FATAL, hash['level']
         assert_equal 1, hash['param']
       end
@@ -80,6 +90,10 @@ class TestNotifier < Test::Unit::TestCase
         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
@@ -99,10 +113,12 @@ class TestNotifier < Test::Unit::TestCase
         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
+      should "be compatible with Airbrake" do
+        # https://github.com/airbrake/airbrake/blob/master/README.md, 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',   hash['error_class']
+        assert_equal 'Message', hash['error_message']
       end
 
       should "set file and line" do
@@ -129,8 +145,7 @@ class TestNotifier < Test::Unit::TestCase
     context "serialize_hash" do
       setup do
         @notifier.level_mapping = :direct
-        @notifier.instance_variable_set('@hash', { 'level' => GELF::WARN, 'field' => 'value' })
-        @data = @notifier.__send__(:serialize_hash)
+        @data = @notifier.__send__(:serialize_hash, { 'level' => GELF::WARN, 'field' => 'value' })
         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
@@ -145,8 +160,7 @@ class TestNotifier < Test::Unit::TestCase
 
     context "datagrams_from_hash" do
       should "not split short data" do
-        @notifier.instance_variable_set('@hash', { 'version' => '1.0', 'short_message' => 'message' })
-        datagrams = @notifier.__send__(:datagrams_from_hash)
+        datagrams = @notifier.__send__(:datagrams_from_hash, { 'version' => '1.0', 'short_message' => 'message' })
         assert_equal 1, datagrams.count
         assert_instance_of String, datagrams[0]
         assert_equal "\x78\x9c", datagrams[0][0..1] # zlib header
@@ -156,8 +170,7 @@ class TestNotifier < Test::Unit::TestCase
         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.instance_variable_set('@hash', hash)
-        datagrams = @notifier.__send__(:datagrams_from_hash)
+        datagrams = @notifier.__send__(:datagrams_from_hash, hash)
         assert_equal 2, datagrams.count
         datagrams.each_index do |i|
           datagram = datagrams[i]

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: gelf
 version: !ruby/object:Gem::Version 
-  hash: 31
-  prerelease: 
+  hash: -3453770742
+  prerelease: 6
   segments: 
   - 1
-  - 3
-  - 2
-  version: 1.3.2
+  - 4
+  - 0
+  - beta
+  - 1
+  version: 1.4.0.beta1
 platform: ruby
 authors: 
 - Alexey Palazhchenko
@@ -16,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-02 00:00:00 Z
+date: 2012-01-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
@@ -77,6 +79,7 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- benchmarks/incremental.rb
 - benchmarks/notifier.rb
 - gelf.gemspec
 - lib/gelf.rb
@@ -109,16 +112,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Library to send GELF messages to Graylog2 logging server.