syslog-sd 1.2.0

data/CHANGELOG

@@ -0,0 +1,2 @@
+1.2.0, 2010-05-17:
+ + Initial version, based on master branch of `gelf` gem.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2011 Lennart Koopmann, Alexey Palazhchenko
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,21 @@
+= syslog-sd
+
+Super-Duper library to send syslog messages to logging server such as Graylog2 (http://graylog2.org).
+Supports Structured Data elements as defined by RFC 5424.
+
+Based on GELF gem (https://github.com/graylog2/gelf-rb).
+
+Works with Ruby 1.8.7 and 1.9.2. 1.8.6 is not supported.
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010-2011 Lennart Koopmann and Alexey Palazhchenko. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,98 @@
+require 'rake'
+
+begin
+  require 'ci/reporter/rake/test_unit'
+rescue LoadError
+  # nothing
+end
+
+begin
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+    gem.name = "syslog-sd"
+    gem.summary = 'Library to send syslog messages to logging server such as Graylog2. Supports Structured Data elements as defined by RFC 5424.'
+    gem.description = 'Super-Duper library to send syslog messages to logging server such as Graylog2. ' +
+                      'Supports Structured Data elements as defined by RFC 5424.'
+    gem.email = "alexey.palazhchenko@gmail.com"
+    gem.homepage = "http://github.com/AlekSi/syslog-sd-rb"
+    gem.authors = ["Alexey Palazhchenko", "Lennart Koopmann"]
+    gem.add_development_dependency "shoulda"
+    gem.add_development_dependency "mocha"
+    gem.add_development_dependency "timecop"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError => e
+  puts e
+  abort "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :test => :check_dependencies
+task :default => :test
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.rcov_opts << '--exclude gem'
+    test.verbose = true
+  end
+rescue LoadError => e
+  task :rcov do
+    puts e
+    abort "rcov is not available. Run: gem install rcov"
+  end
+end
+
+begin
+  gem 'ruby_parser', '~> 2.0.6'
+  gem 'activesupport', '~> 3.0.0'
+  gem 'metric_fu', '~> 2.1.1'
+  require 'metric_fu'
+
+  MetricFu::Configuration.run do |config|
+    # Saikuro is useless
+    config.metrics -= [:saikuro]
+
+    config.flay     = { :dirs_to_flay  => ['lib'],
+                        :minimum_score => 10  }
+    config.flog     = { :dirs_to_flog  => ['lib'] }
+    config.reek     = { :dirs_to_reek  => ['lib'] }
+    config.roodi    = { :dirs_to_roodi => ['lib'] }
+    config.rcov     = { :environment => 'test',
+                        :test_files => ['test/test_*.rb'],
+                        :rcov_opts => ["-I 'lib:test'",
+                                       "--sort coverage",
+                                       "--no-html",
+                                       "--text-coverage",
+                                       "--no-color",
+                                       "--exclude /test/,/gems/"]}
+    config.graph_engine = :gchart
+  end
+
+rescue LoadError, NameError => e
+  desc 'Generate all metrics reports'
+  task :'metrics:all' do
+    puts e.inspect
+    # puts e.backtrace
+    abort "metric_fu is not available. Run: gem install metric_fu"
+  end
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "syslog-sd #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.2.0

data/benchmarks/notifier.rb

@@ -0,0 +1,36 @@
+#! /usr/bin/env ruby
+
+puts "Loading..."
+
+require 'benchmark'
+require 'rubygems'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'syslog-sd'
+
+puts "Generating random data..."
+srand(1)
+RANDOM_DATA = ('A'..'z').to_a
+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
+
+SHORT_HASH = { 'short_message' => 'message' }
+LONG_HASH  = { 'short_message' => 'message', 'long_message' => k3_message }
+
+
+notifier = SyslogSD::Notifier.new(TARGET_HOST, TARGET_PORT, DEFAULT_OPTIONS)
+
+# to create mongo collections, etc.
+notifier.notify!(LONG_HASH)
+sleep(5)
+
+puts "Sending #{TIMES} notifications...\n"
+tms = Benchmark.bm(25) do |b|
+  b.report('short data') { TIMES.times { notifier.notify!(SHORT_HASH) } }
+  sleep(5)
+  b.report('long data ') { TIMES.times { notifier.notify!(LONG_HASH) } }
+end

data/lib/syslog-sd.rb

@@ -0,0 +1,7 @@
+require 'socket'
+require 'digest/md5'
+
+require 'syslog-sd/severity'
+require 'syslog-sd/ruby_sender'
+require 'syslog-sd/notifier'
+require 'syslog-sd/logger'

data/lib/syslog-sd/logger.rb

@@ -0,0 +1,55 @@
+module SyslogSD
+  # 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, progname = if args.count == 2
+                            [args[0], args[1]]
+                          elsif args.count == 0
+                            [yield, default_options['facility']]
+                          elsif block_given?
+                            [yield, args[0]]
+                          else
+                            [args[0], default_options['facility']]
+                          end
+
+      hash = {'short_message' => message, 'facility' => progname}
+      hash.merge!(self.class.extract_hash_from_exception(message)) if message.is_a?(Exception)
+      notify_with_level(level, hash)
+    end
+
+    # Redefines methods in +Notifier+.
+    SyslogSD::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(SyslogSD::#{const}, *args)              #   add(SyslogSD::DEBUG, *args)
+        end                                           # end
+
+        def #{const.downcase}?                        # def debug?
+          SyslogSD::#{const} >= level                 #   SyslogSD::DEBUG >= level
+        end                                           # end
+      EOT
+    end
+
+    def <<(message)
+      notify_with_level(SyslogSD::UNKNOWN, 'short_message' => message)
+    end
+  end
+
+  # Graylog2 notifier, compatible with Ruby Logger.
+  # You can use it with Rails like this:
+  #     config.logger = SyslogSD::Logger.new("localhost", 12201, "WAN", { :facility => "appname" })
+  #     config.colorize_logging = false
+  class Logger < Notifier
+    include LoggerCompatibility
+    @last_chunk_id = 0
+  end
+end

data/lib/syslog-sd/notifier.rb

@@ -0,0 +1,214 @@
+module SyslogSD
+  # syslog notifier.
+  class Notifier
+    attr_accessor :enabled, :collect_file_and_line
+    attr_reader :level, :default_options, :level_mapping
+
+    # +host+ and +port+ are host/ip and port of syslog server.
+    # +default_options+ is used in notify!
+    def initialize(host = 'localhost', port = 514, default_options = {})
+      @enabled = true
+      @collect_file_and_line = true
+      @sd_id = "_@37797"
+
+      self.level = SyslogSD::DEBUG
+
+      self.default_options = default_options
+      self.default_options['host'] ||= Socket.gethostname
+      self.default_options['level'] ||= SyslogSD::UNKNOWN
+      self.default_options['facility'] ||= 'syslog-sd-rb'
+      self.default_options['procid'] ||= Process.pid
+
+      @sender = RubyUdpSender.new([[host, port]])
+      self.level_mapping = :logger
+    end
+
+    # Get a list of receivers.
+    #    notifier.addresses  # => [['localhost', 12201], ['localhost', 12202]]
+    def addresses
+      @sender.addresses
+    end
+
+    # Set a list of receivers.
+    #    notifier.addresses = [['localhost', 12201], ['localhost', 12202]]
+    def addresses=(addrs)
+      @sender.addresses = addrs
+    end
+
+    def host
+      warn "SyslogSD::Notifier#host is deprecated. Use #addresses instead."
+      self.addresses.first[0]
+    end
+
+    def port
+      warn "SyslogSD::Notifier#port is deprecated. Use #addresses instead."
+      self.addresses.first[1]
+    end
+
+    def level=(new_level)
+      @level = if new_level.is_a?(Fixnum)
+                 new_level
+               else
+                 SyslogSD.const_get(new_level.to_s.upcase)
+               end
+    end
+
+    def default_options=(options)
+      @default_options = self.class.stringify_keys(options)
+    end
+
+    # +mapping+ may be a hash, 'logger' (SyslogSD::LOGGER_MAPPING) or 'direct' (SyslogSD::DIRECT_MAPPING).
+    # Default (compatible) value is 'logger'.
+    def level_mapping=(mapping)
+      case mapping.to_s.downcase
+        when 'logger'
+          @level_mapping = SyslogSD::LOGGER_MAPPING
+        when 'direct'
+          @level_mapping = SyslogSD::DIRECT_MAPPING
+        else
+          @level_mapping = mapping
+      end
+    end
+
+    def disable
+      @enabled = false
+    end
+
+    def enable
+      @enabled = true
+    end
+
+    # Same as notify!, but rescues all exceptions (including +ArgumentError+)
+    # and sends them instead.
+    def notify(*args)
+      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):
+    #    notify!(:short_message => 'All your rebase are belong to us', :user => 'AlekSi')
+    # - 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:
+    #    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)
+      notify_with_level!(nil, *args)
+    end
+
+    SyslogSD::Levels.constants.each do |const|
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{const.downcase}(*args)                          # def debug(*args)
+          notify_with_level(SyslogSD::#{const}, *args)        #   notify_with_level(SyslogSD::DEBUG, *args)
+        end                                                   # end
+      EOT
+    end
+
+  private
+    def notify_with_level(message_level, *args)
+      notify_with_level!(message_level, *args)
+    rescue Exception => exception
+      notify_with_level!(SyslogSD::UNKNOWN, exception)
+    end
+
+    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_datagram(serialize_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'] ||= SyslogSD::ERROR
+                       self.class.extract_hash_from_exception(object)
+                     else
+                       args['level'] ||= SyslogSD::INFO
+                       { '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
+      check_presence_of_mandatory_attributes
+      @hash
+    end
+
+    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
+
+    # 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')
+        end
+      end
+    end
+
+    CALLER_REGEXP = /^(.*):(\d+).*/
+    LIB_PATTERN = File.join('lib', 'syslog-sd')
+
+    def set_file_and_line
+      stack = caller
+      begin
+        frame = stack.shift
+      end while frame.include?(LIB_PATTERN)
+      match = CALLER_REGEXP.match(frame)
+      @hash['file'] = match[1]
+      @hash['line'] = match[2].to_i
+    end
+
+    def check_presence_of_mandatory_attributes
+      %w(short_message host).each do |attribute|
+        if @hash[attribute].to_s.empty?
+          raise ArgumentError.new("#{attribute} is missing. Options short_message and host must be set.")
+        end
+      end
+    end
+
+    def serialize_hash
+      raise ArgumentError.new("Hash is empty.") if @hash.nil? || @hash.empty?
+
+      @hash['level'] = @level_mapping[@hash['level']]
+
+      prival = 128 + @hash.delete('level') # 128 = 16(local0) * 8
+      t = Time.now.utc
+      timestamp = t.strftime("%Y-%m-%dT%H:%M:%S.#{t.usec.to_s[0,3]}Z")
+      host = @hash.delete('host')
+      facility = @hash.delete('facility') || '-'
+      procid = @hash.delete('procid')
+      msgid = @hash.delete('msgid') || '-'
+      short_message = @hash.delete('short_message')
+      "<#{prival}>1 #{timestamp} #{host} #{facility} #{procid} #{msgid} #{serialize_sd} #{short_message}"
+    end
+
+    def serialize_sd
+      return '-' if @hash.empty?
+
+      res = "@sd_id"
+      @hash.each_pair do |key, value|
+        value = value.to_s.gsub(/([\\\]\"])/) { "\\#{$1}" }
+        res += " #{key}=\"#{value}\""
+      end
+      '[' + res + ']'
+    end
+
+    def self.stringify_keys(hash)
+      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
+    end
+  end
+end

data/lib/syslog-sd/ruby_sender.rb

@@ -0,0 +1,18 @@
+module SyslogSD
+  # Plain Ruby UDP sender.
+  class RubyUdpSender
+    attr_accessor :addresses
+
+    def initialize(addresses)
+      @addresses = addresses
+      @i = 0
+      @socket = UDPSocket.open
+    end
+
+    def send_datagram(datagram)
+      host, port = @addresses[@i]
+      @i = (@i + 1) % @addresses.length
+      @socket.send(datagram, 0, host, port)
+    end
+  end
+end

data/lib/syslog-sd/severity.rb

@@ -0,0 +1,37 @@
+module SyslogSD
+  # There are two things you should know about log levels/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 syslog message, using defined mapping.
+
+  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. This one is default.
+  LOGGER_MAPPING = {DEBUG   => 7, # Debug
+                    INFO    => 6, # Info
+                    WARN    => 5, # Notice
+                    ERROR   => 4, # Warning
+                    FATAL   => 3, # Error
+                    UNKNOWN => 1} # Alert – shouldn't be used
+
+  # Maps Ruby Logger levels to syslog levels as is.
+  DIRECT_MAPPING = {DEBUG   => 7, # Debug
+                    INFO    => 6, # Info
+                    # skip 5 Notice
+                    WARN    => 4, # Warning
+                    ERROR   => 3, # Error
+                    FATAL   => 2, # Critical
+                    UNKNOWN => 1} # Alert – shouldn't be used
+end

data/syslog-sd.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{syslog-sd}
+  s.version = "1.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Alexey Palazhchenko}, %q{Lennart Koopmann}]
+  s.date = %q{2011-05-17}
+  s.description = %q{Super-Duper library to send syslog messages to logging server such as Graylog2. Supports Structured Data elements as defined by RFC 5424.}
+  s.email = %q{alexey.palazhchenko@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    "CHANGELOG",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "benchmarks/notifier.rb",
+    "lib/syslog-sd.rb",
+    "lib/syslog-sd/logger.rb",
+    "lib/syslog-sd/notifier.rb",
+    "lib/syslog-sd/ruby_sender.rb",
+    "lib/syslog-sd/severity.rb",
+    "syslog-sd.gemspec",
+    "test/helper.rb",
+    "test/test_logger.rb",
+    "test/test_notifier.rb",
+    "test/test_ruby_sender.rb",
+    "test/test_severity.rb"
+  ]
+  s.homepage = %q{http://github.com/AlekSi/syslog-sd-rb}
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.2}
+  s.summary = %q{Library to send syslog messages to logging server such as Graylog2. Supports Structured Data elements as defined by RFC 5424.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<timecop>, [">= 0"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<timecop>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<timecop>, [">= 0"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'timecop'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'syslog-sd'
+
+class Test::Unit::TestCase
+end

data/test/test_logger.rb

@@ -0,0 +1,139 @@
+require 'helper'
+
+class TestLogger < Test::Unit::TestCase
+  context "with logger with mocked sender" do
+    setup do
+      Socket.stubs(:gethostname).returns('stubbed_hostname')
+      @logger = SyslogSD::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, '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 == SyslogSD::INFO &&
+          hash['short_message'] == 'Message' &&
+          hash['facility'] == 'syslog-sd-rb'
+        end
+        @logger.add(SyslogSD::INFO, '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 == SyslogSD::INFO &&
+          hash['short_message'] == 'RuntimeError: Boom!' &&
+          hash['full_message'] =~ /^Backtrace/ &&
+          hash['facility'] == 'syslog-sd-rb'
+        end
+        @logger.add(SyslogSD::INFO, 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 == SyslogSD::INFO &&
+          hash['short_message'] == 'Message' &&
+          hash['facility'] == 'syslog-sd-rb'
+        end
+        @logger.add(SyslogSD::INFO) { '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 == SyslogSD::INFO &&
+          hash['short_message'] == 'RuntimeError: Boom!' &&
+          hash['full_message'] =~ /^Backtrace/ &&
+          hash['facility'] == 'syslog-sd-rb'
+        end
+        @logger.add(SyslogSD::INFO) { 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 == SyslogSD::INFO &&
+          hash['short_message'] == 'Message' &&
+          hash['facility'] == 'Facility'
+        end
+        @logger.add(SyslogSD::INFO, 'Message', 'Facility')
+      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 == SyslogSD::INFO &&
+          hash['short_message'] == 'RuntimeError: Boom!' &&
+          hash['full_message'] =~ /^Backtrace/ &&
+          hash['facility'] == 'Facility'
+        end
+        @logger.add(SyslogSD::INFO, RuntimeError.new('Boom!'), 'Facility')
+      end
+
+      # logger.add(Logger::INFO, '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 == SyslogSD::INFO &&
+          hash['short_message'] == 'Message' &&
+          hash['facility'] == 'Facility'
+        end
+        @logger.add(SyslogSD::INFO, 'Facility') { 'Message' }
+      end
+
+      # logger.add(Logger::INFO, '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 == SyslogSD::INFO &&
+          hash['short_message'] == 'RuntimeError: Boom!' &&
+          hash['full_message'] =~ /^Backtrace/ &&
+          hash['facility'] == 'Facility'
+        end
+        @logger.add(SyslogSD::INFO, 'Facility') { RuntimeError.new('Boom!') }
+      end
+    end
+
+    SyslogSD::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(:add).with(SyslogSD.const_get(const), 'message')
+        @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(:add).with(SyslogSD.const_get(const), 'message')
+        @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(:add).with(SyslogSD.const_get(const), 'message', 'facility')
+        @logger.__send__(const.downcase, 'facility') { 'message' }
+      end
+
+      should "respond to #{const.downcase}?" do
+        @logger.level = SyslogSD.const_get(const) - 1
+        assert @logger.__send__(const.to_s.downcase + '?')
+        @logger.level = SyslogSD.const_get(const)
+        assert @logger.__send__(const.to_s.downcase + '?')
+        @logger.level = SyslogSD.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 == SyslogSD::UNKNOWN &&
+        hash['short_message'] == "Message"
+      end
+      @logger << "Message"
+    end
+  end
+end

data/test/test_notifier.rb

@@ -0,0 +1,214 @@
+require 'helper'
+
+RANDOM_DATA = ('A'..'Z').to_a
+
+class TestNotifier < Test::Unit::TestCase
+  should "allow access to host, port and default_options" do
+    Socket.expects(:gethostname).returns('default_hostname')
+    n = SyslogSD::Notifier.new
+    assert_equal [['localhost', 514]], n.addresses
+    assert_equal( { 'level' => SyslogSD::UNKNOWN,
+                    'host' => 'default_hostname', 'facility' => 'syslog-sd-rb',
+                    'procid' => Process.pid },
+                  n.default_options )
+    n.addresses, n.default_options = [['graylog2.org', 7777]], {:host => 'grayhost'}
+    assert_equal [['graylog2.org', 7777]], n.addresses
+    assert_equal({'host' => 'grayhost'}, n.default_options)
+  end
+
+  context "with notifier with mocked sender" do
+    setup do
+      Socket.stubs(:gethostname).returns('stubbed_hostname')
+      @notifier = SyslogSD::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 SyslogSD::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' => SyslogSD::FATAL, 'short_message' => 'will be hidden by exception'}
+        hash = @notifier.__send__(:extract_hash, e, h)
+        assert_equal 'RuntimeError: message', hash['short_message']
+        assert_equal SyslogSD::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 SyslogSD::INFO, hash['level']
+      end
+
+      should "work with plain text and hash" do
+        hash = @notifier.__send__(:extract_hash, 'message', 'level' => SyslogSD::WARN)
+        assert_equal 'message', hash['short_message']
+        assert_equal SyslogSD::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
+    end
+
+    context "serialize_hash" do
+      setup do
+        @notifier.level_mapping = :direct
+        Timecop.freeze(Time.utc(2010, 5, 16, 12, 13, 14))
+      end
+
+      expected = {
+        {'short_message' => 'message', 'level' => SyslogSD::WARN,
+         'host' => 'host', 'facility' => 'facility', 'procid' => 123,
+         'msgid' => 'msgid'} => '<132>1 2010-05-16T12:13:14.0Z host facility 123 msgid - message',
+        {'short_message' => 'message', 'level' => SyslogSD::WARN,
+         'host' => 'host', 'facility' => 'facility', 'procid' => 123,
+         'msgid' => 'msgid', 'user_id' => 123} => '<132>1 2010-05-16T12:13:14.0Z host facility 123 msgid [@sd_id user_id="123"] message',
+        {'short_message' => 'message', 'level' => SyslogSD::WARN,
+         'host' => 'host', 'facility' => 'facility', 'procid' => 123,
+         'msgid' => 'msgid', 'user_id' => '\\"]'} => '<132>1 2010-05-16T12:13:14.0Z host facility 123 msgid [@sd_id user_id="\\\\\"\]"] message'
+      }
+
+      expected.each_pair do |key, value|
+        should "be as #{value}" do
+          @notifier.instance_variable_set('@hash', key)
+          assert_equal value, @notifier.__send__(:serialize_hash)
+        end
+      end
+
+      teardown do
+        Timecop.return
+      end
+    end
+
+    context "level threshold" do
+      setup do
+        @notifier.level = SyslogSD::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 SyslogSD::DEBUG, @notifier.level
+        end
+      end
+
+      should "not send notifications with level below threshold" do
+        @sender.expects(:send_datagram).never
+        @notifier.notify!(@hash.merge('level' => SyslogSD::DEBUG))
+      end
+
+      should "not notifications with level equal or above threshold" do
+        @sender.expects(:send_datagram).once
+        @notifier.notify!(@hash.merge('level' => SyslogSD::WARN))
+      end
+    end
+
+    context "when disabled" do
+      setup do
+        @notifier.disable
+      end
+
+      should "not send datagram" do
+        @sender.expects(:send_datagram).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 datagram" do
+          @sender.expects(:send_datagram)
+          @notifier.notify!({ 'version' => '1.0', 'short_message' => 'message' })
+        end
+      end
+    end
+
+    should "pass valid data to sender" do
+      @sender.expects(:send_datagram).with do |datagram|
+        datagram.is_a?(String)
+      end
+      @notifier.notify!({ 'version' => '1.0', 'short_message' => 'message' })
+    end
+
+    SyslogSD::Levels.constants.each do |const|
+      should "call notify with level #{const} from method name" do
+        @notifier.expects(:notify_with_level).with(SyslogSD.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(SyslogSD::UNKNOWN, instance_of(ArgumentError))
+      assert_nothing_raised { @notifier.notify(:no_short_message => 'too bad') }
+    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 = SyslogSD::RubyUdpSender.new(@addresses)
+    end
+
+    context "send_datagram" do
+      setup do
+        @sender.send_datagram("d1")
+        @sender.send_datagram("e1")
+        @sender.send_datagram("d2")
+        @sender.send_datagram("e2")
+      end
+
+      before_should "be called 2 times with 1st and 2nd address" do
+        UDPSocket.any_instance.expects(:send).times(2).with do |datagram, _, host, port|
+          datagram.start_with?('d') && host == 'localhost' && port == 12201
+        end
+        UDPSocket.any_instance.expects(:send).times(2).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
+    SyslogSD::LOGGER_MAPPING.each do |ruby_level, syslog_level|
+      assert_not_equal syslog_level, ruby_level
+    end
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification 
+name: syslog-sd
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: 
+  segments: 
+  - 1
+  - 2
+  - 0
+  version: 1.2.0
+platform: ruby
+authors: 
+- Alexey Palazhchenko
+- Lennart Koopmann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-17 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: timecop
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Super-Duper library to send syslog messages to logging server such as Graylog2. Supports Structured Data elements as defined by RFC 5424.
+email: alexey.palazhchenko@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- CHANGELOG
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- benchmarks/notifier.rb
+- lib/syslog-sd.rb
+- lib/syslog-sd/logger.rb
+- lib/syslog-sd/notifier.rb
+- lib/syslog-sd/ruby_sender.rb
+- lib/syslog-sd/severity.rb
+- syslog-sd.gemspec
+- test/helper.rb
+- test/test_logger.rb
+- test/test_notifier.rb
+- test/test_ruby_sender.rb
+- test/test_severity.rb
+homepage: http://github.com/AlekSi/syslog-sd-rb
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  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: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.2
+signing_key: 
+specification_version: 3
+summary: Library to send syslog messages to logging server such as Graylog2. Supports Structured Data elements as defined by RFC 5424.
+test_files: []
+