logglier 0.1.1 → 0.2.0

data/lib/logglier/client/http/sync.rb

@@ -1,32 +1,56 @@
 module Logglier
-
   module Client
+    class HTTP
 
-    module HTTP
+      # Used to wrap and setup Net::HTTP as we need it
+      class NetHTTPProxy
 
-      class Sync
-        include Logglier::Client::InstanceMethods
-        include Logglier::Client::HTTP::InstanceMethods
+        # @param [URI] input_uri URI to deliver messages to
+        # @param [Hash] opts Option hash
+        # @option [Integer] read_timeout Read timeout for the http session. defaults to 2
+        # @option [Integer] open_timeout Open timeout for the http session. defaults to 2
+        # @option [Integer] verify_mode OpenSSL::SSL::VERIFY_* constant
+        # @option [String] ca_file Path to the ca file
+        def initialize(input_uri, opts={})
+          @input_uri = input_uri
 
-        attr_reader :input_uri, :http
+          @http = Net::HTTP.new(@input_uri.host, @input_uri.port)
 
-        def initialize(opts={})
-          setup_input_uri(opts)
+          if @input_uri.scheme == 'https'
+            @http.use_ssl = true
+            @http.verify_mode = opts[:verify_mode] || OpenSSL::SSL::VERIFY_PEER
+            @http.ca_file = opts[:ca_file] if opts[:ca_file]
+          end
 
-          setup_http(opts)
-        end
+          # We prefer persistent HTTP connections, so workaround http://redmine.ruby-lang.org/issues/4522
+          @http.start
 
-        # Required by Logger::LogDevice
-        def write(message)
-          deliver(message)
+          @http.read_timeout = opts[:read_timeout] || 2
+          @http.open_timeout = opts[:open_timeout] || 2
         end
 
-        # Required by Logger::LogDevice
-        def close
-          nil
+        # Delivers the message via HTTP, handling errors
+        #
+        # @param [String] message The message to deliver
+        def deliver(message)
+          retried = false
+          begin
+            @http.request_post(@input_uri.path, message)
+          # We're using persistent connections, so connection can be closed by the other side
+          # after a timeout. Don't consider it an error, just retry once.
+          rescue Errno::ECONNRESET
+            unless retried
+              retried = true
+              retry
+            else
+              $stderr.puts "WARNING: connection was reset while posting message: #{message}"
+            end
+          rescue TimeoutError, OpenSSL::SSL::SSLError, EOFError, Errno::ECONNRESET => e
+            $stderr.puts "WARNING: #{e.class} posting message: #{message}"
+          end
         end
-
       end
+
     end
   end
 end

data/lib/logglier/client/http/threaded.rb

@@ -1,28 +1,31 @@
 require 'thread'
 
 module Logglier
-
   module Client
-
-    module HTTP
+    class HTTP
 
       # Used by the Threaded client to hold a queue, deliver messsages from it
       # and to ensure it's flushed on program exit.
       #
-      # Not meant to be used directly.
+      # @note Uses NetHTTPProxy
+      #
       class DeliveryThread < Thread
-        include Logglier::Client::HTTP::InstanceMethods
 
-        # @param [URI] input_uri The uri to deliver messags to
-        # @param [Integer] read_timeout Read timeout for the http session. defaults to 120
-        # @param [Integer] open_timeout Open timeout for the http session. defaults to 120
+        # @param [URI] input_uri The uri to deliver messages to
+        # @param [Hash] opts Option hash
+        # @option [Integer] read_timeout Read timeout for the http session. defaults to 120
+        # @option [Integer] open_timeout Open timeout for the http session. defaults to 120
         #
+        # @note See NetHTTPProxy for further option processing of opts
         # @note registers an at_exit handler that signals exit intent and joins the thread.
-        def initialize(input_uri, read_timeout=120, open_timeout=120)
+        def initialize(input_uri, opts={})
 
           @input_uri = input_uri
 
-          setup_http( {:read_timeout => read_timeout, :open_timeout => open_timeout} )
+          opts[:read_timeout] = opts[:read_timeout] || 120
+          opts[:open_timeout] = opts[:open_timeout] || 120
+
+          @http = Logglier::Client::HTTP::NetHTTPProxy.new(@input_uri, opts)
 
           @queue = Queue.new
           @exiting = false
@@ -31,7 +34,7 @@ module Logglier
             loop do
               msg = @queue.pop
               break if msg == :__delivery_thread_exit_signal__
-              deliver(msg)
+              @http.deliver(msg)
             end
           end
 
@@ -48,36 +51,11 @@ module Logglier
         end
 
         # Pushes a message onto the internal queue
-        def push(message)
+        def deliver(message)
           @queue.push(message)
         end
       end
 
-      # Interface to the DeliveryThread
-      class Threaded
-        include Logglier::Client::InstanceMethods
-
-        attr_reader :input_uri, :delivery_thread
-
-        def initialize(opts={})
-          setup_input_uri(opts)
-          @delivery_thread = DeliveryThread.new(@input_uri, opts[:read_timeout] || 120, opts[:open_timeout] || 120)
-        end
-
-        # Required by Logger::LogDevice
-        # @param [String] message the message to deliver
-        #
-        # @note doesn't do actual deliver. Pushes the messages off to the delivery thread
-        def write(message)
-          @delivery_thread.push(message)
-        end
-
-        # Required by Logger::LogDevice
-        def close
-          nil
-        end
-
-      end
     end
   end
 end

data/lib/logglier/client/http.rb

@@ -1,52 +1,33 @@
 require 'net/https'
 require 'uri'
 
+require File.join(File.dirname(__FILE__), 'http', 'sync')
+require File.join(File.dirname(__FILE__), 'http', 'threaded')
+
 module Logglier
   module Client
-    module HTTP
+    class HTTP
+      include Logglier::Client::InstanceMethods
+
+      attr_reader :input_uri, :deliverer
 
-      def self.new(opts={})
-        if opts[:threaded]
-          Logglier::Client::HTTP::Threaded.new(opts)
+      def initialize(opts={})
+        setup_input_uri(opts)
+        @deliverer = if opts[:threaded]
+          Logglier::Client::HTTP::DeliveryThread.new(@input_uri, opts)
         else
-          Logglier::Client::HTTP::Sync.new(opts)
+          Logglier::Client::HTTP::NetHTTPProxy.new(@input_uri, opts)
         end
       end
 
-      module InstanceMethods
-
-        # Sets up @http 
-        #
-        # @param [Hash] opts The options Hash
-        # @option opts [String] :read_timeout The read timeout for the http connection
-        # @option opts [String] :open_timeout The open timeout for the http connection
-        def setup_http(opts={})
-          @http = Net::HTTP.new(@input_uri.host, @input_uri.port)
-          if @input_uri.scheme == 'https'
-            @http.use_ssl = true
-            @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          end
-
-          @http.read_timeout = opts[:read_timeout] || 2
-          @http.open_timeout = opts[:open_timeout] || 2
-        end
-
-        # Delivers the message via HTTP, handling errors
-        #
-        # @param [String] message The message to deliver
-        def deliver(message)
-          begin
-            @http.request_post(@input_uri.path, message)
-          rescue TimeoutError, OpenSSL::SSL::SSLError, EOFError, Errno::ECONNRESET => e
-            $stderr.puts "WARNING: #{e.class} posting message: #{message}"
-          end
-        end
-
+      def write(message)
+        @deliverer.deliver(message)
       end
 
+      def close
+        nil
+      end
     end
   end
 end
 
-require File.join(File.dirname(__FILE__), 'http', 'sync')
-require File.join(File.dirname(__FILE__), 'http', 'threaded')

data/lib/logglier/version.rb

@@ -1,3 +1,3 @@
 module Logglier
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/spec/client_spec.rb

@@ -16,9 +16,13 @@ describe Logglier::Client do
 
       context "that is a valid http uri" do
 
+        before do
+          Logglier::Client::HTTP::NetHTTPProxy.stub(:new) { MockNetHTTPProxy.new }
+        end
+
         it "should return an instance of the proper client" do
           log = Logglier::Client.new('http://localhost')
-          log.should be_an_instance_of Logglier::Client::HTTP::Sync
+          log.should be_an_instance_of Logglier::Client::HTTP
         end
 
       end
@@ -62,51 +66,77 @@ describe Logglier::Client do
 
   end
 
-  context "HTTPS" do
-    context "#write" do
-      context "with a simple text message" do
-        it "should post a message" do
-          log = Logglier::Client.new('https://localhost')
-          log.http.stub(:request_post)
-          log.http.should_receive(:request_post).with('','msg')
-          log.write('msg')
-        end
-      end
+  context "message formatting methods" do
+
+    before do
+      Logglier::Client::HTTP::NetHTTPProxy.stub(:new) { MockNetHTTPProxy.new }
     end
 
-    context "message formatting methods" do
-      subject { Logglier::Client.new('https://localhost') }
+    subject { Logglier::Client.new('https://localhost') }
 
-      it "should mash out hashes" do
-        message = subject.massage_message({:foo => :bar},"WARN")
-        message.should =~ /^severity=WARN,/
-        message.should =~ /foo=bar/
-      end
+    it "should mash out hashes" do
+      message = subject.massage_message({:foo => :bar},"WARN")
+      message.should =~ /^severity=WARN,/
+      message.should =~ /foo=bar/
+    end
 
-      it "should mash out nested hashes" do
-        message = subject.massage_message({:foo => :bar, :bazzle => { :bom => :bastic } }, "WARN")
-        message.should =~ /^severity=WARN,/
-        message.should =~ /foo=bar/
-        message.should =~ /bazzle\.bom=bastic/
-      end
+    it "should mash out nested hashes" do
+      message = subject.massage_message({:foo => :bar, :bazzle => { :bom => :bastic } }, "WARN")
+      message.should =~ /^severity=WARN,/
+      message.should =~ /foo=bar/
+      message.should =~ /bazzle\.bom=bastic/
+    end
+
+    it "should mash out deeply nested hashes" do
+      message = subject.massage_message({:foo => :bar, :bazzle => { :bom => :bastic, :totally => { :freaking => :funny } } }, "WARN")
+      message.should =~ /^severity=WARN,/
+      message.should =~ /foo=bar/
+      message.should =~ /bazzle\.bom=bastic/
+      message.should =~ /bazzle\.totally\.freaking=funny/
+    end
 
-      it "should mash out deeply nested hashes" do
-        message = subject.massage_message({:foo => :bar, :bazzle => { :bom => :bastic, :totally => { :freaking => :funny } } }, "WARN")
-        message.should =~ /^severity=WARN,/
-        message.should =~ /foo=bar/
-        message.should =~ /bazzle\.bom=bastic/
-        message.should =~ /bazzle\.totally\.freaking=funny/
+    it "should mash out deeply nested hashes, with an array" do
+      message = subject.massage_message({:foo => :bar, :taste => ["this","sauce"], :bazzle => { :bom => :bastic, :totally => { :freaking => :funny } } }, "WARN")
+      message.should =~ /^severity=WARN,/
+      message.should =~ /foo=bar/
+      message.should =~ /taste=\["this", "sauce"\]/
+      message.should =~ /bazzle\.bom=bastic/
+      message.should =~ /bazzle\.totally\.freaking=funny/
+    end
+  end
+
+  context "HTTPS" do
+
+    before do
+      @mock_http = MockNetHTTPProxy.new
+      Logglier::Client::HTTP::NetHTTPProxy.stub(:new) { @mock_http }
+    end
+
+    context "Sync" do
+      context "#write" do
+        context "with a simple text message" do
+          it "should deliver a message" do
+            log = Logglier::Client.new('https://localhost')
+            @mock_http.should_receive(:deliver).with('msg')
+            log.write('msg')
+          end
+        end
       end
+    end
 
-      it "should mash out deeply nested hashes, with an array" do
-        message = subject.massage_message({:foo => :bar, :taste => ["this","sauce"], :bazzle => { :bom => :bastic, :totally => { :freaking => :funny } } }, "WARN")
-        message.should =~ /^severity=WARN,/
-        message.should =~ /foo=bar/
-        message.should =~ /taste=\["this", "sauce"\]/
-        message.should =~ /bazzle\.bom=bastic/
-        message.should =~ /bazzle\.totally\.freaking=funny/
+    context "Threaded" do
+      context "#write" do
+        context "with a simple text message" do
+          it "should deliver a message" do
+            log = Logglier::Client.new('https://localhost', :threaded => true)
+            @mock_http.should_receive(:deliver).with('msg')
+            log.write('msg')
+            sleep 5
+          end
+        end
       end
     end
+
   end
 
   context "Syslog" do

data/spec/http_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'HTTP' do
+  before do
+    @http = mock('Net::HTTP')
+    @http.stub!(:start)
+    @http.stub!(:read_timeout=)
+    @http.stub!(:open_timeout=)
+    Net::HTTP.stub!(:new).and_return(@http)
+    @proxy = Logglier::Client::HTTP::NetHTTPProxy.new(URI.parse('http://localhost:9292'))
+  end
+
+  it "retries after connection is reset" do
+    @http.should_receive(:request_post).and_raise Errno::ECONNRESET
+    @http.should_receive(:request_post)
+    @proxy.deliver('message')
+  end
+
+  it "retries only once connection is reset" do
+    @http.should_receive(:request_post).exactly(2).times.and_raise Errno::ECONNRESET
+    @proxy.deliver('message')
+  end
+  it "fails for other errors" do
+    @http.should_receive(:request_post).once.and_raise EOFError
+    @proxy.deliver('message')
+  end
+end

data/spec/logglier_spec.rb

@@ -1,4 +1,9 @@
+require 'spec_helper'
+
 describe Logglier do
+  before do
+    Logglier::Client::HTTP::NetHTTPProxy.stub(:new) { MockNetHTTPProxy.new }
+  end
 
   context "HTTPS" do
 
@@ -6,7 +11,7 @@ describe Logglier do
       subject { new_logglier('https://localhost') }
 
       it { should be_an_instance_of Logger }
-      its('logdev.dev') { should be_an_instance_of Logglier::Client::HTTP::Sync }
+      its('logdev.dev') { should be_an_instance_of Logglier::Client::HTTP }
 
       it_should_behave_like "a logglier enhanced Logger instance"
     end
@@ -15,7 +20,7 @@ describe Logglier do
       subject { new_logglier('https://localhost', :threaded => true) }
 
       it { should be_an_instance_of Logger }
-      its('logdev.dev') { should be_an_instance_of Logglier::Client::HTTP::Threaded }
+      its('logdev.dev') { should be_an_instance_of Logglier::Client::HTTP }
 
       it_should_behave_like "a logglier enhanced Logger instance"
     end

data/spec/spec_helper.rb

@@ -21,6 +21,11 @@ RSpec.configure do |config|
     def send(*args); end
   end
 
+  class MockNetHTTPProxy
+    def initialize(*args); end
+    def deliver(*args); end
+  end
+
   def new_logglier(url,opts={})
     log = Logglier.new(url,opts)
     log.extend(LoggerHacks)

data/spec/threaded_spec.rb

@@ -1,14 +1,16 @@
-describe Logglier::Client::HTTP::DeliveryThread do
-
-  subject { described_class.new(URI.parse('http://localhost')) }
+require 'spec_helper'
 
+describe Logglier::Client::HTTP::DeliveryThread do
   before do
-    subject.stub(:deliver)
+    @mock_http = MockNetHTTPProxy.new
+    Logglier::Client::HTTP::NetHTTPProxy.stub(:new) { @mock_http }
   end
 
-  it "should" do
-    subject.should_receive(:deliver).with("test")
-    subject.push('test')
+  subject { described_class.new(URI.parse('http://localhost')) }
+
+  it "should deliver the message" do
+    @mock_http.should_receive(:deliver).with("test")
+    subject.deliver('test')
 
     #Signal the thread it's going to exit
     subject.exit!

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: logglier
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Edward Muller (aka freeformz)
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-11 00:00:00 -07:00
+date: 2011-06-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -72,6 +72,7 @@ files:
 - ./lib/logglier/version.rb
 - ./lib/logglier.rb
 - ./spec/client_spec.rb
+- ./spec/http_spec.rb
 - ./spec/logglier_spec.rb
 - ./spec/spec_helper.rb
 - ./spec/threaded_spec.rb
@@ -111,6 +112,7 @@ specification_version: 3
 summary: Loggly 'plugin' for Logger
 test_files: 
 - ./spec/client_spec.rb
+- ./spec/http_spec.rb
 - ./spec/logglier_spec.rb
 - ./spec/spec_helper.rb
 - ./spec/threaded_spec.rb