gelf_redux 3.2.2 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04ecbd3c8710b26b4c7b2f292e17a15837e1879cd8b807671bfa18110994fb73
-  data.tar.gz: efc1b6c00d89f2286f42dacd4693fb8ed2e1476e0f1329a0740e914486d48424
+  metadata.gz: aec46d611ec7a79e16d8a48a91d95eb95d0c296e50ee9d0b6c26dd3533c5226b
+  data.tar.gz: c533a7819a33d5290652c91ea2aa6c4d2d58d7a5cd2a582da46d41964e8d0278
 SHA512:
-  metadata.gz: 004e466c37f91d3c4da2b63da20f161d32ded4ee01496a992f7466f36c103ce82943d9baa515231ff461ccd60a8421c21e829fa1b066e26c5e600dff5350796d
-  data.tar.gz: 1c583a57fbab8c0749d7e9b580a612e52bc3a0dc10c9b9c50580139a5c38021ba651b76d83b7d5456a8a2748b5575a9ea405e8bc4f1248735b144e5193a900bf
+  metadata.gz: 4b4e41d8fd082bbb4970957df73a1591e2cec1dd6addfa0aa3bdc0e862d1d7d401541333394f2d1e79b4026bd8db8ebe9f1961d58ce35618cbcb4240b1284924
+  data.tar.gz: a4d3426cff78ec20f00d28e5e5dafa5e9e37d040ddff4a3cd7269740d2bee23ab07551ef7bbcd0a3ff03f39bde40d7ce0e2a043f0dcf962754020008b7821281

data/README.md

@@ -1,4 +1,4 @@
-## GELF (anew) Ruby library
+## GELF (redux) Ruby library
 This gem is intended to replace the existing and unmaintained gelf-rb https://github.com/graylog-labs/gelf-rb - since
 the project went silent for a few years and there seems to be no intention in continuing any kind of support
 (https://github.com/graylog-labs/gelf-rb/issues/93). So we decided to not just fork but set up a new gem.
@@ -65,6 +65,16 @@ Since it's compatible with the Logger interface, you can also use it in your Rai
   (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
+## Contributions
+* Feel free to open up pull request
 
-Copyright (c) 2010-2016 Lennart Koopmann and Alexey Palazhchenko. See LICENSE for details.
+### Running the tests
+* install docker with compose
+
+```bash
+# install gems
+docker-compose run app bundle
+
+# run tests
+docker-compose up
+```

data/lib/gelf/logger.rb

@@ -14,7 +14,8 @@ module GELF
         progname = default_options['facility']
       end
 
-      message_hash = { 'facility' => progname }
+      message_hash = {}
+      message_hash['facility'] = progname if progname
 
       if message.is_a?(Hash)
         message.each do |key, value|

data/lib/gelf/notifier.rb

@@ -1,12 +1,19 @@
 require 'gelf/transport/udp'
 require 'gelf/transport/tcp'
 require 'gelf/transport/tcp_tls'
+require 'gelf/transport/http'
 require 'gelf/transport/https'
 
 # replace JSON and #to_json with Yajl if available
 begin
-  require 'yajl/json_gem'
+  require 'yajl'
+  def json_dump(obj)
+    Yajl.dump(obj)
+  end
 rescue LoadError
+  def json_dump(obj)
+    JSON.dump(obj)
+  end
 end
 
 module GELF
@@ -36,7 +43,6 @@ module GELF
       self.default_options['version'] = SPEC_VERSION
       self.default_options['host'] ||= Socket.gethostname
       self.default_options['level'] ||= GELF::UNKNOWN
-      self.default_options['facility'] ||= 'gelf-rb'
       self.default_options['protocol'] ||= GELF::Protocol::UDP
 
       self.level_mapping = :logger
@@ -59,12 +65,12 @@ module GELF
     # Default (safe) value is 'WAN'.
     def max_chunk_size=(size)
       case size.to_s.downcase
-        when 'wan'
-          @max_chunk_size = MAX_CHUNK_SIZE_WAN
-        when 'lan'
-          @max_chunk_size = MAX_CHUNK_SIZE_LAN
-        else
-          @max_chunk_size = size.to_int
+      when 'wan'
+        @max_chunk_size = MAX_CHUNK_SIZE_WAN
+      when 'lan'
+        @max_chunk_size = MAX_CHUNK_SIZE_LAN
+      else
+        @max_chunk_size = size.to_int
       end
     end
 
@@ -84,12 +90,12 @@ module GELF
     # Default (compatible) value is 'logger'.
     def level_mapping=(mapping)
       case mapping.to_s.downcase
-        when 'logger'
-          @level_mapping = GELF::LOGGER_MAPPING
-        when 'direct'
-          @level_mapping = GELF::DIRECT_MAPPING
-        else
-          @level_mapping = mapping
+      when 'logger'
+        @level_mapping = GELF::LOGGER_MAPPING
+      when 'direct'
+        @level_mapping = GELF::DIRECT_MAPPING
+      else
+        @level_mapping = mapping
       end
     end
 
@@ -133,11 +139,12 @@ module GELF
       end
     end
 
-  private
+    private
 
     def create_sender(host, port)
-      return create_https(host, port) if default_options['protocol'] == GELF::Protocol::HTTPS
-
+      if [GELF::Protocol::HTTP, GELF::Protocol::HTTPS].include? default_options['protocol']
+        return create_http(host, port)
+      end
       addresses = [[host, port]]
       if default_options['protocol'] == GELF::Protocol::TCP
         if default_options.key?('tls')
@@ -151,8 +158,13 @@ module GELF
       end
     end
 
-    def create_https(host, port)
-      GELF::Transport::HTTPS.new host, port: port, path: default_options.delete('path')
+    def create_http(host, port)
+      klass = if default_options['protocol'] == GELF::Protocol::HTTPS
+                GELF::Transport::HTTPS
+              else
+                GELF::Transport::HTTP
+              end
+      klass.new host, port: port, path: default_options.delete('path'), headers: default_options.delete('headers')
     end
 
     def notify_with_level(message_level, *args)
@@ -168,11 +180,12 @@ module GELF
       hash = extract_hash(*args)
       hash['level'] = message_level unless message_level.nil?
       if hash['level'] >= level
-        return @sender.transfer(hash) if default_options['protocol'] == GELF::Protocol::HTTPS
-
+        if [GELF::Protocol::HTTP, GELF::Protocol::HTTPS].include? default_options['protocol']
+          return @sender.transfer(hash)
+        end
         if default_options['protocol'] == GELF::Protocol::TCP
           validate_hash(hash)
-          @sender.send(hash.to_json + "\0")
+          @sender.send(json_dump(hash) + "\0")
         else
           @sender.send_datagrams(datagrams_from_hash(hash))
         end
@@ -190,7 +203,9 @@ module GELF
                        { 'short_message' => object.to_s }
                      end
 
-      hash = default_options.merge(self.class.stringify_keys(args.merge(primary_data)))
+      default_message_data = default_options.dup
+      default_message_data.delete('protocol')
+      hash = default_message_data.merge(self.class.stringify_keys(args.merge(primary_data)))
       convert_hoptoad_keys_to_graylog2(hash)
       set_file_and_line(hash) if @collect_file_and_line
       set_timestamp(hash)
@@ -269,7 +284,7 @@ module GELF
     def serialize_hash(hash)
       validate_hash(hash)
 
-      Zlib::Deflate.deflate(hash.to_json).bytes
+      Zlib::Deflate.deflate(json_dump(hash)).bytes
     end
 
     def self.stringify_keys(data)

data/lib/gelf/transport/http.rb

@@ -0,0 +1,37 @@
+module GELF
+  module Transport
+    class HTTP
+      def initialize(host, port: 80, path: '', headers: nil)
+        @uri = URI::HTTP.build host: host, port: port
+        @headers = headers
+        @path = path
+      end
+
+      def start_connection
+        @uri.path = "/#{@path.to_s.delete_prefix('/')}"
+        @http = Net::HTTP.new(@uri.host, @uri.port)
+        @http.use_ssl = true if @uri.instance_of? URI::HTTPS
+        given_headers = @headers || {}
+        @headers = default_headers.merge(given_headers)
+      end
+
+      def transfer(message)
+        start_connection
+        request = Net::HTTP::Post.new(@uri.request_uri)
+        request.body = json_dump(message)
+        @headers.each do |key, value|
+          # pass header only if value present -> allows clearing default headers
+          request[key] = value if value
+        end
+        @http.request(request)
+      end
+
+      def default_headers
+        {
+          'Accept' => 'application/json',
+          'Content-Type' => 'application/json'
+        }
+      end
+    end
+  end
+end

data/lib/gelf/transport/https.rb

@@ -0,0 +1,11 @@
+module GELF
+  module Transport
+    class HTTPS < HTTP
+      def initialize(host, port: 443, path: nil, headers: nil)
+        @uri = URI::HTTPS.build host: host, port: port
+        @headers = headers
+        @path = path
+      end
+    end
+  end
+end

data/lib/gelf.rb

@@ -4,11 +4,12 @@ require 'zlib'
 require 'digest/md5'
 
 module GELF
-  SPEC_VERSION = '1.0'
+  SPEC_VERSION = '1.1'
   module Protocol
     UDP = 0
     TCP = 1
-    HTTPS = 2
+    HTTP = 2
+    HTTPS = 3
   end
 end
 

data/lib/gelf_redux.rb

@@ -0,0 +1 @@
+require 'gelf'

metadata

@@ -1,19 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: gelf_redux
 version: !ruby/object:Gem::Version
-  version: 3.2.2
+  version: 4.0.1
 platform: ruby
 authors:
 - Alexey Palazhchenko
 - Lennart Koopmann
 - Zac Sprackett
 - Marcus Ilgner
-- Sebastian Seidel
 - Christian Rolle
+- Sebastian Seidel
+- Ronald Sacher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-19 00:00:00.000000000 Z
+date: 2023-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
@@ -21,56 +22,98 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.11.3
+        version: 4.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.11.3
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.0.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.0.4
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 3.6.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 3.6.0
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 0.20.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 0.20.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.18.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.18.1
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -86,37 +129,24 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Library to send GELF messages to Graylog logging server. Supports plain-text,
-  GELF messages and exceptions via UDP, TCP and HTTPS
+  GELF messages and exceptions via UDP, TCP and HTTP(S)
 email: admins@manet-marketing.de
 executables: []
 extensions: []
-extra_rdoc_files:
-- LICENSE
-- README.md
+extra_rdoc_files: []
 files:
-- ".gemtest"
-- CHANGELOG
-- CONTRIBUTING.md
-- Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
-- Rakefile
-- VERSION
-- benchmarks/notifier.rb
-- gelf.gemspec
 - lib/gelf.rb
 - lib/gelf/logger.rb
 - lib/gelf/notifier.rb
 - lib/gelf/severity.rb
+- lib/gelf/transport/http.rb
+- lib/gelf/transport/https.rb
 - lib/gelf/transport/tcp.rb
 - lib/gelf/transport/tcp_tls.rb
 - lib/gelf/transport/udp.rb
-- test/helper.rb
-- test/test_logger.rb
-- test/test_notifier.rb
-- test/test_ruby_sender.rb
-- test/test_severity.rb
+- lib/gelf_redux.rb
 homepage: https://github.com/manet-marketing/gelf_redux
 licenses:
 - MIT
@@ -129,7 +159,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '1.9'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/CHANGELOG

@@ -1,54 +0,0 @@
-3.0.0, 2016-08-21
- + Overhaul TCP support
- + Include automatic support for Celluloid::IO if available
- + Add TLS support to TCP transport
- - Remove support for ancient Rubygems versions
- - Remove support for Ruby 1.9.2 (1.9.3 works!)
- - Remove already-deprecated `host` and `port` methods on GELF::Notifier
-
-2.0.0, 2016-02-02
- + Added GELF TCP support.
-
-1.3.2, 2011-12-02:
- * support for rubygems-test.
- * rescue from more network errors.
-
-1.3.1, 2011-10-28:
- + allow to rescue from network errors.
-
-1.3.0, 2011-07-27:
- + allow to set timestamp manually.
-
-1.2.0.beta1, 2011-05-23:
- + compatibility with GELF specification 1.0:
-   * requires modern graylog2-server and graylog2-web-interface;
- + Notifier#default_options, Notifier#default_options=;
- + severity (level) threshold;
- + automatically set 'file', 'line' and 'timestamp' fields;
- + 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
- + allow to change severity mapping;
- + send messages to receivers in round-robin;
-   * GELF::Notifier#host and #port are attr_readers now and deprecated (were attr_accessor);
- + allow to disable file and line collection (GELF::Notifier#collect_file_and_line = false);
- - deprecated Gelf class removed.
-
-1.0.2, 2010-11-29:
-1.0.1, 2010-11-29:
- - added more tests for chunking in attempt to locate not existing bug.
-
-1.0.0, 2010-11-10:
- + initial stable version;
- * deprecated Gelf class is still there.

data/CONTRIBUTING.md

@@ -1 +0,0 @@
-Please follow [the instructions on graylog.org](https://www.graylog.org/contributing-to-graylog/).

data/Gemfile

@@ -1,10 +0,0 @@
-source "https://rubygems.org"
-
-group :development do
-  gem "shoulda", "~> 2.11.3"
-  # Because of a dependency chain jeweler->github_api->oauth2->rack,
-  # pin the version: Rack 2.0.x doesn't work on < Ruby 2.2
-  gem 'rack', '< 2.0'
-  gem "mocha", "~> 1.1.0"
-  gem "test-unit", "~> 3.2.0"
-end

data/Gemfile.lock

@@ -1,24 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    metaclass (0.0.4)
-    mocha (1.1.0)
-      metaclass (~> 0.0.1)
-    power_assert (0.3.0)
-    rack (1.6.4)
-    shoulda (2.11.3)
-    test-unit (3.2.1)
-      power_assert
-
-PLATFORMS
-  java
-  ruby
-
-DEPENDENCIES
-  mocha (~> 1.1.0)
-  rack (< 2.0)
-  shoulda (~> 2.11.3)
-  test-unit (~> 3.2.0)
-
-BUNDLED WITH
-   1.17.3

data/Rakefile

@@ -1,41 +0,0 @@
-require 'rake'
-
-begin
-  require 'ci/reporter/rake/test_unit'
-rescue LoadError
-  # nothing
-end
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-
-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
-
-#require 'rake/rdoctask'
-#Rake::RDocTask.new do |rdoc|
-#  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-#
-#  rdoc.rdoc_dir = 'rdoc'
-#  rdoc.title = "gelf #{version}"
-#  rdoc.rdoc_files.include('README*')
-#  rdoc.rdoc_files.include('lib/**/*.rb')
-#end

data/VERSION

@@ -1 +0,0 @@
-3.1.0

data/benchmarks/notifier.rb

@@ -1,39 +0,0 @@
-#! /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 'gelf'
-
-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_lan = GELF::Notifier.new(TARGET_HOST, TARGET_PORT, 'LAN', DEFAULT_OPTIONS)
-notifier_wan = GELF::Notifier.new(TARGET_HOST, TARGET_PORT, 'WAN', DEFAULT_OPTIONS)
-
-# to create mongo collections, etc.
-notifier_lan.notify!(LONG_HASH)
-sleep(5)
-
-puts "Sending #{TIMES} notifications...\n"
-tms = Benchmark.bm(25) do |b|
-  b.report('lan, short data, 1 chunk ') { TIMES.times { notifier_lan.notify!(SHORT_HASH) } }
-  sleep(5)
-  b.report('lan,  long data, 1 chunk ') { TIMES.times { notifier_lan.notify!(LONG_HASH) } }
-  sleep(5)
-  b.report('wan,  long data, 2 chunks') { TIMES.times { notifier_wan.notify!(LONG_HASH) } }
-end

data/gelf.gemspec

@@ -1,73 +0,0 @@
-Gem::Specification.new do |s|
-  s.name = "gelf_redux"
-  s.version = "3.2.2"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.required_ruby_version = ">= 1.9"
-  s.require_paths = ["lib"]
-  s.authors = ["Alexey Palazhchenko", "Lennart Koopmann", "Zac Sprackett", "Marcus Ilgner", "Sebastian Seidel", "Christian Rolle"]
-  s.date = "2023-06-19"
-  s.description = "Library to send GELF messages to Graylog logging server. Supports plain-text, GELF messages and exceptions via UDP, TCP and HTTPS"
-  s.email = "admins@manet-marketing.de"
-  s.extra_rdoc_files = [
-    "LICENSE",
-    "README.md"
-  ]
-  s.files = [
-    ".gemtest",
-    "CHANGELOG",
-    "CONTRIBUTING.md",
-    "Gemfile",
-    "Gemfile.lock",
-    "LICENSE",
-    "README.md",
-    "Rakefile",
-    "VERSION",
-    "benchmarks/notifier.rb",
-    "gelf.gemspec",
-    "lib/gelf.rb",
-    "lib/gelf/logger.rb",
-    "lib/gelf/notifier.rb",
-    "lib/gelf/severity.rb",
-    "lib/gelf/transport/tcp.rb",
-    "lib/gelf/transport/tcp_tls.rb",
-    "lib/gelf/transport/udp.rb",
-    "test/helper.rb",
-    "test/test_logger.rb",
-    "test/test_notifier.rb",
-    "test/test_ruby_sender.rb",
-    "test/test_severity.rb"
-  ]
-  s.homepage = "https://github.com/manet-marketing/gelf_redux"
-  s.licenses = ["MIT"]
-  s.rubygems_version = "2.5.1"
-  s.summary = "Library to send GELF messages to Graylog logging server."
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('3.2.0') then
-      s.add_development_dependency(%q<typhoeus>, ["~> 1.4.0"])
-    end
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<shoulda>, ["~> 2.11.3"])
-      s.add_development_dependency(%q<rack>, ["< 2.0"])
-      s.add_development_dependency(%q<mocha>, ["~> 1.1.0"])
-      s.add_development_dependency(%q<test-unit>, ["~> 3.2.0"])
-      s.add_runtime_dependency(%q<json>, [">= 0"])
-    else
-      s.add_dependency(%q<shoulda>, ["~> 2.11.3"])
-      s.add_dependency(%q<rack>, ["< 2.0"])
-      s.add_dependency(%q<mocha>, ["~> 1.1.0"])
-      s.add_dependency(%q<test-unit>, ["~> 3.2.0"])
-      s.add_dependency(%q<json>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<shoulda>, ["~> 2.11.3"])
-    s.add_dependency(%q<rack>, ["< 2.0"])
-    s.add_dependency(%q<mocha>, ["~> 1.1.0"])
-    s.add_dependency(%q<test-unit>, ["~> 3.2.0"])
-    s.add_dependency(%q<json>, [">= 0"])
-  end
-end
-

data/test/helper.rb

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

data/test/test_logger.rb

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

data/test/test_notifier.rb

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

data/test/test_ruby_sender.rb

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

data/test/test_severity.rb

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