logstash-logger 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2cb98c8cb41ee7a5cd49492cb17c1c3c06df5f37
-  data.tar.gz: 2c09577089a1a3f4dcb71ae16a426080d456d2b0
+  metadata.gz: e6696816384e341e562b5cf39921a1f8d71accb0
+  data.tar.gz: a510f56283c8a70101dd5604efa2b5470edb5f5f
 SHA512:
-  metadata.gz: fb7d7c1d9f6305721b8aea10d33de1c2d37c19b0de495b06d358fc783082ec3b1ab16d0e7b61be6c6ab621c4452b3509dd6798ca08789c38685d93260e8b8861
-  data.tar.gz: 0ec0923505339d1c9d561aa2e52a54dd7a9cb9cc045ffdaf9e8117db15a58b7eb7df1b5c13b1a7b96426743a0a789326940ea8d2891831f94effb8777c1870d6
+  metadata.gz: a9b42b29215905770c72c3ad7ada65df908302a24e0389d636e0e7c3dbef631c06dfd57a304180adc5acdf3138ed81bb47ed9e8b465393a7c3130be107390892
+  data.tar.gz: ce2711e17ef4ce503da02e1e9561f55b61525d4766bfefda2ba5a794418e990116351b3c57f25939e0bd9be58242cf3e5b68096b72dfeb5576e3267d890df1cc

data/.gitignore

@@ -4,6 +4,7 @@
 .config
 .yardoc
 Gemfile.lock
+*.lock
 InstalledFiles
 _yardoc
 coverage

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format progress
+--require spec_helper

data/.travis.yml

@@ -5,6 +5,9 @@ rvm:
   - 2.1.0
   - 2.1.1
   - 2.1.2
-  - jruby-19mode # JRuby in 1.9 mode
-#  - rbx-18mode
-#  - rbx-19mode
+  - jruby-19mode
+  - rbx-2
+gemfile:
+  - gemfiles/rails_3.2.gemfile
+  - gemfiles/rails_4.0.gemfile
+  - gemfiles/rails_4.1.gemfile

data/Appraisals

@@ -0,0 +1,11 @@
+appraise "rails-3.2" do
+  gem "rails", "~> 3.2.18"
+end
+
+appraise "rails-4.0" do
+  gem "rails", "~> 4.0.0"
+end
+
+appraise "rails-4.1" do
+  gem "rails", "~> 4.1.1"
+end

data/CHANGELOG.md

@@ -1,24 +1,31 @@
-0.4.1
------
+## 0.5.0
+- Support for tagged logging. The interface was extracted from `ActiveSupport::TaggedLogging`
+and outputs to the `tags` key. (Thanks [pctj101](https://github.com/pctj101)!)
+- The `(host, port, type)` constructor has been deprecated in favor of an options hash constructor.
+- Support for using SSL for TCP connections. (Thanks [Gary Rennie](https://github.com/Gazler)!)
+- Support for configuring logger to write to STDOUT. (Thanks [Nick Ethier](https://github.com/nickethier)!)
+- Support for Rails configuration.
+- Fixed output to STDOUT in Rails console (Rails 4+).
+- `host` is no longer required for TCP/UDP. It will default to `0.0.0.0`, the same default port that logstash listens on.
+- Changed event key `source` to `host` to match what the latest logstash expects.
+- Output event timestamp consistently even if `Time#to_json` is overridden.
+- Major refactoring which will lead the way to support other log types.
+
+## 0.4.1
 - Fixed support for `LogStash::Event` v1 format when logging a hash. Extra data
 now goes to the top level instead of into the `@fields` key.
 
-0.4.0
------
+## 0.4.0
 - Support for new `LogStash::Event` v1 format. v0 is supported in 0.3+.
 
-0.3.0
------
+## 0.3.0
 - Added support for logging to a UDP listener.
 
-0.2.1
------
+## 0.2.1
 - Fixed to use Logstash's default time format for timestamps.
 
-0.2.0
------
+## 0.2.0
 - Better use of Ruby Logger's built-in LogDevice.
 
-0.1.0
------
-- Initial release. Support for logging to a TCP listener.
+## 0.1.0
+- Initial release. Support for logging to a TCP listener.

data/Gemfile

@@ -1,11 +1,5 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in logstash-logger.gemspec
 gemspec
 
-gem 'json', :platform => :ruby_18
-
-group :development do
-  #gem 'ruby-debug', :platform => :ruby_18
-  #gem 'debugger', :platforms => [:ruby_19, :ruby_20]
-end
+#gem 'json', :platform => :ruby_18

data/README.md

@@ -36,29 +36,34 @@ The logger accepts a string message, a JSON string, a hash, or a `LogStash::Even
 ```ruby
 require 'logstash-logger'
 
-# Defaults to UDP
-logger = LogStashLogger.new('localhost', 5228)
+# Defaults to UDP on 0.0.0.0
+logger = LogStashLogger.new(port: 5228)
 
-# Specify UDP or TCP explicitly
-udp_logger = LogStashLogger.new('localhost', 5228, :udp)
-tcp_logger = LogStashLogger.new('localhost', 5229, :tcp)
+# Specify host and type (UDP or TCP) explicitly
+udp_logger = LogStashLogger.new(host: 'localhost', port: 5228, type: :udp)
+tcp_logger = LogStashLogger.new(host: 'localhost', port: 5229, type: :tcp)
+stdout_logger = LogStashLogger.new(type: :stdout)
 
 # The following messages are written to UDP port 5228:
 
 logger.info 'test'
-# {"message":"test","@timestamp":"2014-05-22T09:37:19.204-07:00","@version":"1","severity":"INFO","source":"[server-hostname]"}
+# {"message":"test","@timestamp":"2014-05-22T09:37:19.204-07:00","@version":"1","severity":"INFO","host":"[hostname]"}
 
 logger.error '{"message": "error"}'
-# {"message":"error","@timestamp":"2014-05-22T10:10:55.877-07:00","@version":"1","severity":"ERROR","source":"[server-hostname]"}
+# {"message":"error","@timestamp":"2014-05-22T10:10:55.877-07:00","@version":"1","severity":"ERROR","host":"[hostname]"}
 
 logger.debug message: 'test', foo: 'bar'
-# {"message":"test","foo":"bar","@timestamp":"2014-05-22T09:43:24.004-07:00","@version":"1","severity":"DEBUG","source":"[server-hostname]"}
+# {"message":"test","foo":"bar","@timestamp":"2014-05-22T09:43:24.004-07:00","@version":"1","severity":"DEBUG","host":"[hostname]"}
 
 logger.warn LogStash::Event.new(message: 'test', foo: 'bar')
-# {"message":"test","foo":"bar","@timestamp":"2014-05-22T16:44:37.364Z","@version":"1","severity":"WARN","source":"[server-hostname]"}
+# {"message":"test","foo":"bar","@timestamp":"2014-05-22T16:44:37.364Z","@version":"1","severity":"WARN","host":"[hostname]"}
+
+# Tagged logging
+logger.tagged('foo') { logger.fatal('bar') }
+# {"message":"bar","@timestamp":"2014-05-26T20:35:14.685-07:00","@version":"1","severity":"FATAL","host":"[hostname]","tags":["foo"]}
 ```
 
-## Logstash configuration
+## Logstash Configuration
 
 In order for Logstash to correctly receive and parse the event, you will need to
 configure and run a UDP listener that uses the `json_lines` codec:
@@ -73,52 +78,106 @@ input {
 }
 ```
 
-## Rails integration
+See the [samples](https://github.com/dwbutler/logstash-logger/tree/master/samples) directory for more configuration samples.
 
-Add the following to your config/environments/production.rb:
+## UDP vs TCP
+Should you write to a UDP or TCP listener? It depends on your specific needs, but most applications should use the default (UDP).
+
+* UDP is faster because it's asynchronous (fire-and-forget). However, this means that log messages could get dropped. This is okay for most applications.
+* TCP verifies that every message has been received via two-way communication . This could slow your app down to a crawl if the TCP listener is under heavy load.
+
+For a more detailed discussion of UDP vs TCP, I recommend reading this article: [UDP vs. TCP](http://gafferongames.com/networking-for-game-programmers/udp-vs-tcp/)
+
+## SSL
+
+If you are using TCP then there is the option of adding an SSL certificate to the options hash on initialize.
 
 ```ruby
-logger = LogStashLogger.new('localhost', 5228)
-logger.level = Logger::INFO # default is Logger::DEBUG
-config.logger = ActiveSupport::TaggedLogging.new(logger)
+LogStashLogger.new(type: :tcp, port: 5228, ssl_certificate: "/path/to/certificate.crt")
 ```
 
-To get Rails to nicely output its logs in structured logstash format, try one of the following gems:
+The SSL certificate and key can be generated using
 
-* [lograge](https://github.com/roidrage/lograge)
-* [yarder](https://github.com/rurounijones/yarder)
+    openssl req -x509 -batch -nodes -newkey rsa:2048 -keyout logstash.key -out logstash.crt
 
-Currently these gems output a JSON string, which LogStashLogger then parses.
-Future versions of these gems could potentially have deeper integration with LogStashLogger (i.e. by writing LogStash::Event objects).
+You can also enable SSL without a certificate:
 
-## UDP vs TCP
-Should you write to a UDP or TCP listener? It depends on your specific needs, but most applications should use the default (UDP).
+```ruby
+LogStashLogger.new(type: :tcp, port: 5228, ssl_enable: true)
+```
 
-* UDP is faster because it's asynchronous (fire-and-forget). However, this means that log messages could get dropped. This is okay for most applications.
-* TCP verifies that every message has been received via two-way communication . This could slow your app down to a crawl if the TCP listener is under heavy load.
+The following Logstash configuration is required for SSL:
 
-For a more detailed discussion of UDP vs TCP, I recommend reading this article: [UDP vs. TCP](http://gafferongames.com/networking-for-game-programmers/udp-vs-tcp/)
+```ruby
+input {
+  tcp {
+    host => "0.0.0.0"
+    port => 5228
+    codec => json_lines
+    ssl_enable => true
+    ssl_cert => "/path/to/certificate.crt"
+    ssl_key => "/path/to/key.key"
+  }
+}
+```
 
-## Ruby compatibility
+## Rails Integration
 
-Verified to work with:
+Verified to work with both Rails 3 and 4.
+
+Add the following to your `config/environments/production.rb`:
+
+```ruby
+# Optional, defaults to '0.0.0.0'
+config.logstash.host = 'localhost'
+
+# Required for TCP/UDP
+config.logstash.port = 5228
+
+# Optional, defaults to :udp. Possible values are :udp, :tcp, or :stdout
+config.logstash.type = :udp
+
+# Optional, enables SSL when combined with :tcp type
+config.logstash.ssl_enable = true
 
-* MRI Ruby 1.9.3
-* MRI Ruby 2.0.0
-* JRuby 1.7+ (1.9 mode)
+# Optional, Rails sets the default to :info
+config.log_level = :debug
+```
+
+By default, every Rails log message will be written to logstash in `LogStash::Event` JSON format.
+
+For minimal, more-structured logstash events, try one of the following gems:
+
+* [lograge](https://github.com/roidrage/lograge)
+* [yarder](https://github.com/rurounijones/yarder)
 
-Ruby 1.8.7 is not supported because LogStash::Event is not compatible with Ruby 1.8.7. This will probably not change.
+Currently these gems output a JSON string, which LogStashLogger then parses.
+Future versions of these gems could potentially have deeper integration with LogStashLogger (i.e. by writing `LogStash::Event` objects).
+
+## Ruby Compatibility
+
+Verified to work with:
+
+* MRI Ruby 1.9.3, 2.0+, 2.1+
+* JRuby 1.7+
+* Rubinius 2.2+
 
-The specs don't pass in Rubinius yet, but the logger does work.
+Ruby 1.8.7 is not supported.
 
 ## Breaking changes
 
+### Version 0.5+
+ * The `source` event key has been replaced with `host` to better match the latest logstash.
+ * The `(host, port, type)` constructor has been deprecated in favor of an options hash constructor.
+
 ### Version 0.4+
-Logstash::Event decided to go ahead and break the existing JSON format starting in version 1.2+. If you're using this version, you'll need to install
-LogStashLogger version 0.4+. This is not backwards compatible with the old LogStash::Event v1.1.5.
+`LogStash::Event` uses the v1 format starting version 1.2+. If you're using the v1, you'll need to install
+LogStashLogger version 0.4+. This is not backwards compatible with the old `LogStash::Event` v1.1.5, which uses
+the v0 format.
 
 ### Version 0.3+
-Earlier versions of this gem (<= 0.2.1) only implemented a TCP connection. Newer versions (>= 0.3) also implement UDP, and use that as the new default.
+Earlier versions of this gem (<= 0.2.1) only implemented a TCP connection.
+Newer versions (>= 0.3) also implement UDP, and use that as the new default.
 Please be aware if you are using the default constructor and still require TCP, you should add an additional argument:
 
 ```ruby

data/Rakefile

@@ -1,24 +1,22 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require "bundler/setup"
 require 'rspec/core/rake_task'
 
 desc "Run all specs with default options"
 RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = %w[--color]
   t.verbose = false
 end
 
 desc "Run specs with TCP socket"
 RSpec::Core::RakeTask.new("spec:tcp") do |t|
-  ENV['SOCKET_TYPE'] = 'tcp'
-  t.rspec_opts = %w[--color]
+  ENV['TYPE'] = 'tcp'
   t.verbose = false
 end
 
 desc "Run specs with UDP socket"
 RSpec::Core::RakeTask.new("spec:udp") do |t|
-  ENV['SOCKET_TYPE'] = 'udp'
-  t.rspec_opts = %w[--color]
+  ENV['TYPE'] = 'udp'
   t.verbose = false
 end
 

data/gemfiles/rails_3.2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 3.2.18"
+
+gemspec :path => "../"

data/gemfiles/rails_4.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 4.0.0"
+
+gemspec :path => "../"

data/gemfiles/rails_4.1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 4.1.1"
+
+gemspec :path => "../"

data/lib/logstash-logger.rb

@@ -1,9 +1,10 @@
 require 'logstash-logger/version'
 
-require 'socket'
 require 'logstash/event'
 
-require 'logstash-logger/socket'
+require 'logstash-logger/device'
+
 require 'logstash-logger/logger'
-require 'logstash-logger/version'
+require 'logstash-logger/formatter'
 
+require 'logstash-logger/railtie' if defined? Rails

data/lib/logstash-logger/device.rb

@@ -0,0 +1,28 @@
+require 'logstash-logger/device/base'
+
+module LogStashLogger
+  module Device
+    DEFAULT_TYPE = :udp
+
+    autoload :Base, 'logstash-logger/device/base'
+    autoload :Socket, 'logstash-logger/device/socket'
+    autoload :UDP, 'logstash-logger/device/udp'
+    autoload :TCP, 'logstash-logger/device/tcp'
+    autoload :Stdout, 'logstash-logger/device/stdout'
+
+    def self.new(opts)
+      type = opts.delete(:type) || DEFAULT_TYPE
+
+      device_klass_for(type).new(opts)
+    end
+
+    def self.device_klass_for(type)
+      case type
+        when :udp then UDP
+        when :tcp then TCP
+        when :stdout then Stdout
+        else fail ArgumentError, 'Invalid type'
+      end
+    end
+  end
+end

data/lib/logstash-logger/device/base.rb

@@ -0,0 +1,30 @@
+module LogStashLogger
+  module Device
+    class Base
+      attr_reader :io
+
+      def initialize(opts={})
+      end
+
+      def to_io
+        @io
+      end
+
+      def write(message)
+        @io.write(message)
+      end
+
+      def flush
+        @io && @io.flush
+      end
+
+      def close
+        @io && @io.close
+      rescue => e
+        warn "#{self.class} - #{e.class} - #{e.message}"
+      ensure
+        @io = nil
+      end
+    end
+  end
+end

data/lib/logstash-logger/device/socket.rb

@@ -0,0 +1,56 @@
+require 'socket'
+
+module LogStashLogger
+  module Device
+    class Socket < Base
+      DEFAULT_HOST = '0.0.0.0'
+
+      attr_reader :host, :port
+
+      def initialize(opts)
+        @port = opts[:port] || fail(ArgumentError, "Port is required")
+        @host = opts[:host] || DEFAULT_HOST
+      end
+
+      def write(message)
+        with_connection do
+          super
+        end
+      end
+
+      def flush
+        return unless connected?
+        with_connection do
+          super
+        end
+      end
+
+      def to_io
+        with_connection do
+          @io
+        end
+      end
+
+      def connected?
+        !!@io
+      end
+
+      protected
+
+      # Implemented by TCP and UDP devices
+      def connect
+        fail NotImplementedError
+      end
+
+      # Ensure the block is executed with a valid connection
+      def with_connection(&block)
+        connect unless @io
+        yield
+      rescue => e
+        warn "#{self.class} - #{e.class} - #{e.message}"
+        close
+        @io = nil
+      end
+    end
+  end
+end