logstash-logger 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5cc1cc91049d6f846f8d942e4d0281683b904b0f
-  data.tar.gz: c2c7090c2787ea403b466fbfd7efa5dc73a48d6c
+  metadata.gz: 028f82a7160982a2b3d5d7fea16a87b408f28f19
+  data.tar.gz: 31e13e392d3315844dfeb73e7f8b61a764575d60
 SHA512:
-  metadata.gz: 089bc8ab4e842eb8b2184967cf20987cca96d1ae85894b6c705eb05263ed9541dca41048ca01e3d5197eb57f8ec14bbec9f115b8537ef684770012f7f25f6674
-  data.tar.gz: d1f170fafd89df7d792b0e0e6aa15729200ca7b8046f0f31041a5dbdd5f09a0911b11e4553f085f51f273429da5c925324af83d0f40ecb8815072409964bca65
+  metadata.gz: 5c97296f106d4c66323026861e587dc98b2dd00bb53a09fa2de273cbd4bcb2dd8270ffee84e2003fbb0309343a42485d08b104108da512a45f59ba39a312b711
+  data.tar.gz: dec18c3ff5a7d76da22ab9cdb8e62bca254742013b2f12b09298a1753bd8c3f288d35ebd18eb51b7b5eee8afd4545abedcd40a694d48b7d6d621092be3d9a884

data/.travis.yml

@@ -5,6 +5,7 @@ rvm:
   - 2.1.0
   - 2.1.1
   - 2.1.2
+  - 2.1.3
   - jruby-19mode
   - rbx-2
 gemfile:

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## 0.7.0
+- Support for logging to a generic IO object.
+- Support for overriding IO in stdout logger. Fixes [#20](https://github.com/dwbutler/logstash-logger/pull/20).
+Thanks [Arron Mabrey](https://github.com/arronmabrey)!
+- Support for configuring logger with a URI. See [#22](https://github.com/dwbutler/logstash-logger/pull/22).
+Thanks [Arron Mabrey](https://github.com/arronmabrey)!
+- Support logging any object. See [#23](https://github.com/dwbutler/logstash-logger/issues/23).
+
+## 0.6.2
+- Allow type to be specified as a string. Fixes [#19](https://github.com/dwbutler/logstash-logger/pull/19).
+Thanks [Arron Mabrey](https://github.com/arronmabrey)!
+
+## 0.6.1
+- Don't mutate options passed to LogStashLogger. Fixes [#18](https://github.com/dwbutler/logstash-logger/pull/18).
+Thanks [Arron Mabrey](https://github.com/arronmabrey)!
+
 ## 0.6.0
 - Support for logging to a file.
 - Support for logging to a Redis list.

data/README.md

@@ -10,7 +10,7 @@ writing to a file or syslog since logstash can receive the structured data direc
 * Can write directly to logstash over a UDP or TCP/SSL connection.
 * Can write to a file, Redis, a unix socket, or stdout.
 * Always writes in logstash JSON format.
-* Logger can take a string message, a hash, a `LogStash::Event`, or a JSON string as input.
+* Logger can take a string message, a hash, a `LogStash::Event`, an object, or a JSON string as input.
 * Events are automatically populated with message, timestamp, host, and severity.
 * Easily integrates with Rails via configuration.
 
@@ -45,6 +45,7 @@ file_logger = LogStashLogger.new(type: :file, path: 'log/development.log', sync:
 unix_logger = LogStashLogger.new(type: :unix, path: '/tmp/sock')
 redis_logger = LogStashLogger.new(type: :redis)
 stdout_logger = LogStashLogger.new(type: :stdout)
+io_logger = LogStashLogger.new(type: :io, io: io)
 
 # The following messages are written to UDP port 5228:
 
@@ -65,6 +66,27 @@ 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"]}
 ```
 
+## URI Configuration
+You can use a URI to configure your logstash logger instead of a hash. This is useful in environments
+such as Heroku where you may want to read configuration values from the environment. The URI scheme
+is `type://host:port/path`. Some sample URI configurations are given below.
+
+```
+udp://localhost:5228       
+tcp://localhost:5229       
+unix:///tmp/socket
+file:///path/to/file        
+redis://localhost:6379     
+stdout:/
+```
+
+Pass the URI into your logstash logger like so:
+
+```ruby
+# Read the URI from an environment variable
+logger = LogStashLogger.new(uri: ENV['LOGSTASH_URI'])
+```
+
 ## Logstash Configuration
 
 In order for logstash to correctly receive and parse the events, you will need to
@@ -120,9 +142,22 @@ input {
 
 Verified to work with both Rails 3 and 4.
 
+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)
+
+Currently these gems output a JSON string, which LogStashLogger then parses.
+Future versions of these gems could potentially have deeper integration with LogStashLogger
+(e.g. by directly writing `LogStash::Event` objects).
+
+### Rails Configuration
+
 Add the following to your `config/environments/production.rb`:
 
-### Common Options
+#### Common Options
 
 ```ruby
 # Optional, Rails sets the default to :info
@@ -130,9 +165,12 @@ config.log_level = :debug
 
 # Optional, Rails 4 defaults to true in development and false in production
 config.autoflush_log = true
+
+# Optional, use a URI to configure. Useful on Heroku
+config.logstash.uri = ENV['LOGSTASH_URI']
 ```
 
-### UDP
+#### UDP
 ```ruby
 # Optional, defaults to '0.0.0.0'
 config.logstash.host = 'localhost'
@@ -144,7 +182,7 @@ config.logstash.type = :udp
 config.logstash.port = 5228
 ```
 
-### TCP
+#### TCP
 
 ```ruby
 # Optional, defaults to '0.0.0.0'
@@ -160,7 +198,7 @@ config.logstash.type = :tcp
 config.logstash.ssl_enable = true
 ```
 
-### Unix Socket
+#### Unix Socket
 
 ```ruby
 # Required
@@ -170,7 +208,7 @@ config.logstash.type = :unix
 config.logstash.path = '/tmp/sock'
 ```
 
-### Redis
+#### Redis
 
 ```ruby
 # Required
@@ -190,7 +228,7 @@ config.logstash.host = 'localhost'
 config.logstash.port = 6379
 ```
 
-### File
+#### File
 
 ```ruby
 # Required
@@ -200,15 +238,15 @@ config.logstash.type = :file
 config.logstash.path = 'log/production.log'
 ```
 
-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:
+#### IO
 
-* [lograge](https://github.com/roidrage/lograge)
-* [yarder](https://github.com/rurounijones/yarder)
+```ruby
+# Required
+config.logstash.type = :io
 
-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).
+# Required
+config.logstash.io = io
+```
 
 ## Ruby Compatibility
 
@@ -220,7 +258,6 @@ Verified to work with:
 
 Ruby 1.8.7 is not supported.
 
-
 ## What type of logger should I use?
 
 It depends on your specific needs, but most applications should use the default (UDP). Here are the advantages and

data/lib/logstash-logger/device.rb

@@ -12,15 +12,28 @@ module LogStashLogger
     autoload :Unix, 'logstash-logger/device/unix'
     autoload :Redis, 'logstash-logger/device/redis'
     autoload :File, 'logstash-logger/device/file'
+    autoload :IO, 'logstash-logger/device/io'
     autoload :Stdout, 'logstash-logger/device/stdout'
 
     def self.new(opts)
       opts = opts.dup
+
+      if parsed_uri_opts = parse_uri_config(opts)
+        opts = parsed_uri_opts
+      end
+
       type = opts.delete(:type) || DEFAULT_TYPE
 
       device_klass_for(type).new(opts)
     end
 
+    def self.parse_uri_config(opts)
+      if uri = opts[:uri]
+        parsed = ::URI.parse(uri)
+        {type: parsed.scheme, host: parsed.host, port: parsed.port, path: parsed.path}
+      end
+    end
+
     def self.device_klass_for(type)
       case type.to_sym
         when :udp then UDP
@@ -28,6 +41,7 @@ module LogStashLogger
         when :unix then Unix
         when :file then File
         when :redis then Redis
+        when :io then IO
         when :stdout then Stdout
         else fail ArgumentError, 'Invalid type'
       end

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

@@ -0,0 +1,11 @@
+module LogStashLogger
+  module Device
+    class IO < Base
+      def initialize(opts)
+        super
+        @io = opts[:io] || fail(ArgumentError, 'IO is required')
+        @io.sync = sync unless sync.nil?
+      end
+    end
+  end
+end

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

@@ -1,10 +1,8 @@
 module LogStashLogger
   module Device
-    class Stdout < Base
+    class Stdout < IO
       def initialize(opts={})
-        super
-        @io = $stdout
-        @io.sync = sync unless sync.nil?
+        super({io: $stdout}.merge(opts))
       end
 
       def close

data/lib/logstash-logger/formatter.rb

@@ -27,8 +27,8 @@ module LogStashLogger
                 when Hash
                   event_data = data.merge("@timestamp" => time)
                   LogStash::Event.new(event_data)
-                when String
-                  LogStash::Event.new("message" => data, "@timestamp" => time)
+                else
+                  LogStash::Event.new("message" => msg2str(data), "@timestamp" => time)
               end
 
       event['severity'] ||= severity

data/lib/logstash-logger/logger.rb

@@ -4,18 +4,21 @@ require 'logstash-logger/tagged_logging'
 module LogStashLogger
   def self.new(*args)
     opts = extract_opts(*args)
-    @device = Device.new(opts)
+    device = Device.new(opts)
 
-    ::Logger.new(@device).tap do |logger|
+    ::Logger.new(device).tap do |logger|
+      logger.instance_variable_set(:@device, device)
       logger.extend(self)
       logger.extend(TaggedLogging)
       logger.formatter = Formatter.new
     end
   end
 
-  def self.included(base)
+  def self.extended(base)
     base.instance_eval do
-      attr_reader :device
+      class << self
+        attr_reader :device
+      end
 
       def flush
         !!@device.flush

data/lib/logstash-logger/railtie.rb

@@ -6,6 +6,11 @@ module LogStashLogger
 
     logger_options = app.config.logstash
 
+    if parsed_uri_options = LogStashLogger::Device.parse_uri_config(logger_options)
+      logger_options.delete(:uri)
+      logger_options.merge!(parsed_uri_options)
+    end
+
     if logger_options.type == :file
       logger_options.path ||= app.config.paths["log"].first
     end

data/lib/logstash-logger/version.rb

@@ -1,3 +1,3 @@
 module LogStashLogger
-  VERSION = "0.6.2"
+  VERSION = "0.7.0"
 end

data/spec/device/io_spec.rb

@@ -0,0 +1,14 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::IO do
+  include_context 'device'
+
+  let(:subject) { io_device }
+  let(:io) { StringIO.new }
+
+  it "writes to the IO object" do
+    expect(subject.to_io).to eq(io)
+    expect(io).to receive(:write).once
+    subject.write("test")
+  end
+end

data/spec/device/stdout_spec.rb

@@ -1,14 +1,31 @@
 require 'logstash-logger'
 
 describe LogStashLogger::Device::Stdout do
+  let(:stdout) { $stdout }
+
   it "writes to $stdout" do
-    expect(subject.to_io).to eq($stdout)
-    expect($stdout).to receive(:write).once
+    expect(subject.to_io).to eq(stdout)
+    expect(stdout).to receive(:write).once
     subject.write("test")
   end
 
   it "ignores #close" do
-    expect($stdout).not_to receive(:close)
+    expect(stdout).not_to receive(:close)
     subject.close
   end
+
+  context "when the default $stdout has been overridden" do
+    before { $stdout = StringIO.new }
+    after  { $stdout = STDOUT }
+
+    let(:injected_stdout) { STDOUT }
+
+    subject { described_class.new(io: injected_stdout) }
+
+    it "accepts an injectable reference to stdout" do
+      expect(subject.to_io).to eq(injected_stdout)
+      expect(injected_stdout).to receive(:write).once
+      subject.write("test")
+    end
+  end
 end

data/spec/device_spec.rb

@@ -30,4 +30,52 @@ describe LogStashLogger::Device do
     end
   end
 
+  describe ".parse_uri_config" do
+    subject(:parse_uri_config) { described_class.parse_uri_config(uri_config) }
+
+    context "when uri_config is valid" do
+      let(:uri_config) { udp_uri_config }
+      it { is_expected.to eq({type: 'udp', host: 'localhost', port: 5228, path: ''}) }
+    end
+
+    context "when uri is invalid" do
+      let(:uri_config) { invalid_uri_config }
+      specify { expect{ parse_uri_config }.to raise_error(URI::InvalidURIError) }
+    end
+  end
+
+  describe "Parsing URI configurations" do
+    subject(:new_device) { described_class.new(uri_config) }
+
+    context "when URI config is udp" do
+      let(:uri_config) { udp_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::UDP }
+    end
+
+    context "when URI config is tcp" do
+      let(:uri_config) { tcp_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::TCP }
+    end
+
+    context "when URI config is unix" do
+      let(:uri_config) { unix_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::Unix }
+    end
+
+    context "when URI config is file" do
+      let(:uri_config) { file_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::File }
+    end
+
+    context "when URI config is redis" do
+      let(:uri_config) { redis_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::Redis }
+    end
+
+    context "when URI config is stdout" do
+      let(:uri_config) { stdout_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::Stdout }
+    end
+  end
+
 end

data/spec/logger_spec.rb

@@ -120,5 +120,20 @@ describe LogStashLogger do
     expect(listener_event['host']).to eq(hostname)
     expect(listener_event['@timestamp']).to_not be_nil
   end
+
+  it 'takes any object as input and writes a logstash event' do
+    message = Time.now
+
+    expect(logdev).to receive(:write).and_call_original do |event|
+      expect(event).to be_a LogStash::Event
+      expect(event.host).to eql(hostname)
+      expect(event['message']).to eql(message.inspect)
+      expect(event['severity']).to eql('INFO')
+    end
+
+    logger.info(message)
+
+    expect(listener_event['message']).to eq(message.inspect)
+  end
   
 end

data/spec/rails_spec.rb

@@ -14,32 +14,46 @@ end
 Test::Application.initialize!
 
 describe LogStashLogger do
+  include_context 'device'
+
   describe "Rails integration" do
     let(:app) { Rails.application }
     let(:config) { app.config }
+    subject { app.config.logger }
+
+    before(:each) do
+      app.config.logstash.clear
+      app.config.logger = nil
+    end
 
-    describe 'Railtie' do
-      describe 'Rails.logger' do
-        subject { Rails.logger }
+    describe '#setup' do
+      context "when configured with a port" do
+        before(:each) do
+          app.config.logstash.port = PORT
+          app.config.log_level = :info
+          LogStashLogger.setup(app)
+        end
 
-        it { should be_a LogStashLogger }
+        it { is_expected.to be_a LogStashLogger }
 
         it "defaults level to config.log_level" do
           expect(subject.level).to eq(::Logger::INFO)
         end
       end
-    end
 
-    describe '#setup' do
-      before do
-        app.config.logstash.port = PORT
-        LogStashLogger.setup(app)
+      context "when configured with a URI" do
+        before(:each) do
+          app.config.logstash.uri = tcp_uri
+          LogStashLogger.setup(app)
+        end
+
+        it "configures the logger using the URI" do
+          expect(subject.device).to be_a LogStashLogger::Device::TCP
+        end
       end
 
       context "when logstash is not configured" do
-        before do
-          app.config.logstash.clear
-          app.config.logger = nil
+        before(:each) do
           LogStashLogger.setup(app)
         end
 

data/spec/spec_helper.rb

@@ -43,5 +43,22 @@ RSpec.shared_context 'device' do
   let(:file) { Tempfile.new('test') }
   let(:file_device) { LogStashLogger::Device.new(type: :file, path: file.path)}
 
+  let(:io_device) { LogStashLogger::Device.new(type: :io, io: io)}
+
   let(:redis_device) { LogStashLogger::Device.new(type: :redis, sync: true) }
+
+  let(:udp_uri) { "udp://localhost:5228" }
+  let(:tcp_uri) { "tcp://localhost:5229" }
+  let(:unix_uri) { "unix:///some/path/to/socket" }
+  let(:file_uri) { "file://#{file.path}" }
+  let(:redis_uri) { "redis://localhost:6379" }
+  let(:stdout_uri) { "stdout://localhost" }
+
+  let(:invalid_uri_config) { {uri: "non parsable uri"} }
+  let(:udp_uri_config)     { {uri: udp_uri} }
+  let(:tcp_uri_config)     { {uri: tcp_uri} }
+  let(:unix_uri_config)    { {uri: unix_uri} }
+  let(:file_uri_config)    { {uri: file_uri} }
+  let(:redis_uri_config)   { {uri: redis_uri} }
+  let(:stdout_uri_config)  { {uri: stdout_uri} }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-logger
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - David Butler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-20 00:00:00.000000000 Z
+date: 2014-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logstash-event
@@ -160,6 +160,7 @@ files:
 - lib/logstash-logger/device/base.rb
 - lib/logstash-logger/device/connectable.rb
 - lib/logstash-logger/device/file.rb
+- lib/logstash-logger/device/io.rb
 - lib/logstash-logger/device/redis.rb
 - lib/logstash-logger/device/socket.rb
 - lib/logstash-logger/device/stdout.rb
@@ -181,6 +182,7 @@ files:
 - samples/udp.conf
 - samples/unix.conf
 - spec/device/file_spec.rb
+- spec/device/io_spec.rb
 - spec/device/redis_spec.rb
 - spec/device/socket_spec.rb
 - spec/device/stdout_spec.rb
@@ -218,6 +220,7 @@ specification_version: 4
 summary: LogStash Logger for ruby
 test_files:
 - spec/device/file_spec.rb
+- spec/device/io_spec.rb
 - spec/device/redis_spec.rb
 - spec/device/socket_spec.rb
 - spec/device/stdout_spec.rb