loggability 0.15.1 → 0.16.0

data/lib/loggability/logger.rb

@@ -24,36 +24,6 @@ class Loggability::Logger < ::Logger
 	DEFAULT_SHIFT_SIZE = 1048576
 
 
-	# A log device that appends to the object it's constructed with instead of writing
-	# to a file descriptor or a file.
-	class AppendingLogDevice
-
-		### Create a new AppendingLogDevice that will append content to +target+ (a
-		### object that responds to #>>).
-		def initialize( target )
-			@target = target
-		end
-
-
-		######
-		public
-		######
-
-		# The target of the log device
-		attr_reader :target
-
-
-		### Append the specified +message+ to the target.
-		def write( message )
-			@target << message
-		end
-
-		### No-op -- this is here just so Logger doesn't complain
-		def close; end
-
-	end # class AppendingLogDevice
-
-
 	# Proxy for the Logger that injects the name of the object it wraps as the 'progname'
 	# of each log message.
 	class ObjectNameProxy
@@ -273,14 +243,17 @@ class Loggability::Logger < ::Logger
 	### logging to IO objects and files (given a filename in a String), this method can also
 	### set up logging to any object that responds to #<<.
 	def output_to( target, *args )
-		if target.is_a?( Logger::LogDevice ) ||
-		   target.is_a?( Loggability::Logger::AppendingLogDevice )
+		if target.is_a?( Logger::LogDevice ) || target.is_a?( Loggability::LogDevice )
 			self.logdev = target
 		elsif target.respond_to?( :write ) || target.is_a?( String )
 			opts = { :shift_age => args.shift || 0, :shift_size => args.shift || 1048576 }
 			self.logdev = Logger::LogDevice.new( target, **opts )
+		elsif target.respond_to?( :any? ) && target.any?( Loggability::LogDevice )
+			self.logdev = MultiDevice.new( target )
 		elsif target.respond_to?( :<< )
-			self.logdev = AppendingLogDevice.new( target )
+			self.logdev = Loggability::LogDevice.create( :appending, target )
+		elsif target.is_a?( Symbol )
+			self.logdev = Loggability::LogDevice.create( target, *args )
 		else
 			raise ArgumentError, "don't know how to output to %p (a %p)" % [ target, target.class ]
 		end
@@ -311,10 +284,11 @@ class Loggability::Logger < ::Logger
 	end
 
 
-	### Set a new +formatter+ for the logger. If +formatter+ is +nil+ or +:default+, this causes the
-	### logger to fall back to its default formatter. If it's a Symbol other than +:default+, it looks
-	### for a similarly-named formatter under loggability/formatter/ and uses that. If +formatter+ is
-	### an object that responds to #call (e.g., a Proc or a Method object), that object is used directly.
+	### Set a new +formatter+ for the logger. If +formatter+ is +nil+ or +:default+, this causes
+	### the logger to fall back to its default formatter. If it's a Symbol other than +:default+,
+	### it looks for a similarly-named formatter under loggability/formatter/ and uses that. If
+	### +formatter+ is an object that responds to #call (e.g., a Proc or a Method object), that
+	### object is used directly.
 	###
 	### Procs and methods should have the method signature: (severity, datetime, progname, msg).
 	###

data/spec/helpers.rb

@@ -20,7 +20,6 @@ require 'timecop'
 require 'loggability'
 require 'loggability/spechelpers'
 
-
 # Helpers specific to Loggability specs
 module SpecHelpers
 
@@ -106,5 +105,6 @@ RSpec.configure do |c|
 	c.include( Loggability::SpecHelpers )
 	c.filter_run_excluding( :configurability ) unless defined?( Configurability )
 
+
 end
 

data/spec/loggability/log_device/appending_spec.rb

@@ -0,0 +1,27 @@
+# -*- rspec -*-
+#encoding: utf-8
+
+require 'rspec'
+
+require 'loggability/logger'
+require 'loggability/log_device/appending'
+
+
+describe Loggability::LogDevice::Appending do
+
+	let ( :logger ) { described_class.new( [] ) }
+
+
+	it "The target is an array" do
+		expect( logger.target ).to be_instance_of( Array )
+	end
+
+
+	it "can append to the array" do
+		logger.write("log message one")
+		logger.write("log message two")
+		expect( logger.target.size ).to eq( 2 )
+	end
+
+end
+

data/spec/loggability/log_device/datadog_spec.rb

@@ -0,0 +1,67 @@
+# -*- rspec -*-
+#encoding: utf-8
+
+require 'securerandom'
+require 'rspec'
+
+require 'loggability/logger'
+require 'loggability/log_device/datadog'
+
+
+describe Loggability::LogDevice::Datadog do
+
+
+	let( :api_key ) { SecureRandom.hex(24) }
+	let( :http_client ) { instance_double(Net::HTTP) }
+
+
+	it "includes the configured API key in request headers" do
+		device = described_class.new(
+			api_key,
+			max_batch_size: 3,
+			batch_interval: 0.1,
+			executor_class: Concurrent::ImmediateExecutor )
+		device.instance_variable_set( :@http_client, http_client )
+
+		expect( http_client ).to receive( :request ) do |request|
+			expect( request ).to be_a( Net::HTTP::Post )
+			expect( request['Content-type'] ).to match( %r|application/json|i )
+			expect( request['DD-API-KEY'] ).to eq( api_key )
+		end.at_least( :once )
+
+		device.write( "message data" * 10 )  # 120 bytes
+		device.write( "message data" * 100 ) # 1200 bytes
+		device.write( "message data" * 85 )  # 1020 bytes
+		device.write( "message data" * 86 )  # 1032 bytes
+
+		sleep( 0.1 ) until device.logs_queue.empty?
+	end
+
+
+	it "includes the hostname in individual log messages" do
+		device = described_class.new(
+			api_key,
+			max_batch_size: 3,
+			batch_interval: 0.1,
+			executor_class: Concurrent::ImmediateExecutor )
+		device.instance_variable_set( :@http_client, http_client )
+
+		expect( http_client ).to receive( :request ) do |request|
+			expect( request ).to be_a( Net::HTTP::Post )
+
+			data = JSON.parse( request.body )
+
+			expect( data ).to all( be_a Hash )
+			expect( data ).to all( include('hostname' => device.hostname) )
+		end.at_least( :once )
+
+		device.write( "message data" * 10 )  # 120 bytes
+		device.write( "message data" * 100 ) # 1200 bytes
+		device.write( "message data" * 85 )  # 1020 bytes
+		device.write( "message data" * 86 )  # 1032 bytes
+
+		sleep( 0.1 ) until device.logs_queue.empty?
+	end
+
+end
+

data/spec/loggability/log_device/file_spec.rb

@@ -0,0 +1,27 @@
+# -*- rspec -*-
+#encoding: utf-8
+
+require 'tempfile'
+require 'rspec'
+
+require 'loggability/logger'
+require 'loggability/log_device/file'
+
+
+describe Loggability::LogDevice::File do
+
+	let( :logfile ) { Tempfile.new( 'test.log' ) }
+	let( :logger ) { described_class.new( logfile.path ) }
+
+
+	it "The logger is an instance of Loggability::LogDevice::File" do
+		expect( logger ).to be_instance_of( Loggability::LogDevice::File )
+	end
+
+
+	it "The log device is delegated to Ruby's built-in log device" do
+		expect( logger.target ).to be_instance_of( ::Logger::LogDevice )
+	end
+
+end
+

data/spec/loggability/log_device/http_spec.rb

@@ -0,0 +1,148 @@
+# -*- rspec -*-
+
+require_relative '../../helpers'
+
+require 'tempfile'
+require 'rspec'
+
+require 'loggability/log_device/http'
+
+
+describe Loggability::LogDevice::Http do
+
+
+	let( :http_client ) { instance_double(Net::HTTP) }
+
+
+	it "can be created with defaults" do
+		result = described_class.new
+
+		expect( result ).to be_an_instance_of( described_class )
+		expect( result.batch_interval ).to eq( described_class::DEFAULT_BATCH_INTERVAL )
+		expect( result.write_timeout ).to eq( described_class::DEFAULT_WRITE_TIMEOUT )
+	end
+
+
+	it "doesn't start when created" do
+		result = described_class.new
+
+		expect( result ).to_not be_running
+	end
+
+
+	it "sends logs when a full batch is ready" do
+		device = described_class.new( max_batch_size: 3, executor_class: Concurrent::ImmediateExecutor )
+		device.instance_variable_set( :@http_client, http_client )
+
+		expect( http_client ).to receive( :request ) do |request|
+			expect( request ).to be_a( Net::HTTP::Post )
+			expect( request['Content-type'] ).to match( %r|application/json|i )
+			expect( request.body ).to match( /message 1/i )
+			expect( request.body ).to match( /message 2/i )
+			expect( request.body ).to match( /message 3/i )
+		end
+
+		device.write( "Message 1" )
+		device.write( "Message 2" )
+		device.write( "Message 3" )
+		device.write( "Message 4" )
+
+		expect( device.logs_queue ).to have_attributes( length: 1 )
+	end
+
+
+	it "sends logs when enough time has elapsed since the last message" do
+		device = described_class.new(
+			max_batch_size: 3, batch_interval: 0.1, executor_class: Concurrent::ImmediateExecutor )
+		device.instance_variable_set( :@http_client, http_client )
+		device.start
+		device.timer_task.shutdown # Don't let the timer fire
+
+		expect( http_client ).to receive( :request ) do |request|
+			expect( request ).to be_a( Net::HTTP::Post )
+			expect( request['Content-type'] ).to match( %r|application/json|i )
+			expect( request.body ).to match( /message 1/i )
+			expect( request.body ).to match( /message 2/i )
+		end
+
+		device.write( "Message 1" )
+
+		# Now wait for the batch interval to pass and send another
+		sleep device.batch_interval
+		expect( device ).to have_batch_ready
+		device.write( "Message 2" )
+
+		expect( device.logs_queue ).to have_attributes( length: 0 )
+	end
+
+
+	it "sends logs on the batch interval even when messages aren't arriving" do
+		device = described_class.new(
+			max_batch_size: 3, batch_interval: 0.1, executor_class: Concurrent::ImmediateExecutor )
+		device.instance_variable_set( :@http_client, http_client )
+
+		expect( http_client ).to receive( :request ) do |request|
+			expect( request ).to be_a( Net::HTTP::Post )
+			expect( request['Content-type'] ).to match( %r|application/json|i )
+			expect( request.body ).to match( /message 1/i )
+		end
+
+		device.write( "Message 1" )
+
+		# Now wait for the batch interval to pass and send another
+		sleep device.batch_interval * 2
+
+		expect( device.logs_queue ).to have_attributes( length: 0 )
+	end
+
+
+	it "limits messages to the configured byte size constraints" do
+		device = described_class.new(
+			max_batch_size: 3,
+			max_message_bytesize: 1024,
+			batch_interval: 0.1,
+			executor_class: Concurrent::ImmediateExecutor )
+		device.instance_variable_set( :@http_client, http_client )
+
+		expect( http_client ).to receive( :request ) do |request|
+			expect( request ).to be_a( Net::HTTP::Post )
+			expect( request['Content-type'] ).to match( %r|application/json|i )
+
+			data = JSON.parse( request.body )
+
+			expect( data ).to all( have_attributes(bytesize: a_value <= 1024) )
+		end.at_least( :once )
+
+		device.write( "message data" * 10 )  # 120 bytes
+		device.write( "message data" * 100 ) # 1200 bytes
+		device.write( "message data" * 85 )  # 1020 bytes
+		device.write( "message data" * 86 )  # 1032 bytes
+
+		sleep( 0.1 ) until device.logs_queue.empty?
+	end
+
+
+	it "limits the batch to the configured byte size constraints" do
+		device = described_class.new(
+			max_batch_bytesize: 1024,
+			batch_interval: 0.1,
+			executor_class: Concurrent::ImmediateExecutor )
+		device.instance_variable_set( :@http_client, http_client )
+
+		expect( http_client ).to receive( :request ) do |request|
+			expect( request ).to be_a( Net::HTTP::Post )
+			expect( request['Content-type'] ).to match( %r|application/json|i )
+
+			expect( request.body.bytesize ).to be <= 1024
+		end.at_least( :once )
+
+		20.times { device.write( "message data" * 10 )  } # 120 bytes
+		20.times { device.write( "message data" * 100 ) } # 1200 bytes
+		20.times { device.write( "message data" * 85 )  } # 1020 bytes
+		20.times { device.write( "message data" * 86 )  } # 1032 bytes
+
+		sleep( 0.1 ) until device.logs_queue.empty?
+	end
+
+
+end

data/spec/loggability/logger_spec.rb

@@ -106,6 +106,7 @@ describe Loggability::Logger do
 			expect( logger.level ).to eq( :warn )
 		end
 
+
 		it "defaults to :debug level when $DEBUG is true" do
 			begin
 				$DEBUG = true
@@ -115,6 +116,7 @@ describe Loggability::Logger do
 			end
 		end
 
+
 		it "allows its levels to be set with integers like Logger" do
 			newlevel = Logger::DEBUG
 			$stderr.puts "Setting newlevel to %p" % [ newlevel ]
@@ -122,11 +124,13 @@ describe Loggability::Logger do
 			expect( logger.level ).to eq( :debug )
 		end
 
+
 		it "allows its levels to be set with Symbolic level names" do
 			logger.level = :info
 			expect( logger.level ).to eq( :info )
 		end
 
+
 		it "allows its levels to be set with Stringish level names" do
 			logger.level = 'fatal'
 			expect( logger.level ).to eq( :fatal )
@@ -141,12 +145,14 @@ describe Loggability::Logger do
 			expect( logger.logdev.dev ).to be( $stderr )
 		end
 
+
 		it "can be told to log to a file" do
 			tmpfile = Tempfile.new( 'loggability-device-spec' )
 			logger.output_to( tmpfile.path )
 			expect( logger.logdev.dev ).to be_a( File )
 		end
 
+
 		it "supports log-rotation arguments for logfiles" do
 			tmpfile = Tempfile.new( 'loggability-device-spec' )
 			logger.output_to( tmpfile.path, 5, 125000 )
@@ -156,16 +162,45 @@ describe Loggability::Logger do
 			expect( logger.logdev.instance_variable_get(:@shift_size) ).to eq( 125000 )
 		end
 
+
+		it "can be told to log to a file and delegate to ruby's built-in logger log device" do
+			logfile = double( "logfile.log" )
+			expect( Loggability::LogDevice ).to receive( :create ).
+				with( :file, 'log_file.log' ).
+				and_return( logfile )
+
+			logfile = Loggability::LogDevice.create( :file, 'log_file.log' )
+			expect( logger ).to receive( :output_to ).
+				with( logfile ).
+				and_return( nil )
+
+			logger.output_to( logfile )
+
+			expect( logger.logdev ).to be_a( Logger::LogDevice )
+		end
+
+
+		it "can be told to log to a custom log device type" do
+			logger.output_to( :http, 'https://logapi.example.com:41133/v1/logintake' )
+
+			device = logger.logdev
+
+			expect( device ).to be_a( Loggability::LogDevice::Http )
+			expect( device.endpoint.to_s ).to eq( 'https://logapi.example.com:41133/v1/logintake' )
+		end
+
+
 		it "can be told to log to an Array" do
 			logmessages = []
 			logger.output_to( logmessages )
-			expect( logger.logdev ).to be_a( Loggability::Logger::AppendingLogDevice )
+			expect( logger.logdev ).to be_a( Loggability::LogDevice::Appending )
 			logger.level = :debug
 			logger.info( "Something happened." )
 			expect( logmessages.size ).to eq(  1  )
 			expect( logmessages.first ).to match( /something happened/i )
 		end
 
+
 		it "doesn't re-wrap a Logger::LogDevice" do
 			tmpfile = Tempfile.new( 'loggability-device-spec' )
 			logger.output_to( tmpfile.path, 5, 125000 )
@@ -176,7 +211,8 @@ describe Loggability::Logger do
 			expect( logger.logdev ).to be( original_logdev )
 		end
 
-		it "doesn't re-wrap an AppendingLogDevice" do
+
+		it "doesn't re-wrap an Appending log device" do
 			log_array = []
 			logger.output_to( log_array )
 			logger.output_to( logger.logdev )
@@ -193,11 +229,13 @@ describe Loggability::Logger do
 			expect( logger.formatter ).to be_a( Loggability::Formatter::Default )
 		end
 
+
 		it "can be told to use the default formatter explicitly" do
 			logger.format_as( :default )
 			expect( logger.formatter ).to be_a( Loggability::Formatter::Default )
 		end
 
+
 		it "can be told to use a block as a formatter" do
 			logger.format_with do |severity, datetime, progname, msg|
 				original_formatter.call(severity, datetime, progname, msg.dump)
@@ -206,11 +244,13 @@ describe Loggability::Logger do
 			expect( logger.formatter ).to be_a( Proc )
 		end
 
+
 		it "can be told to use the HTML formatter" do
 			logger.format_as( :html )
 			expect( logger.formatter ).to be_a( Loggability::Formatter::HTML )
 		end
 
+
 		it "supports formatting with ::Logger::Formatter, too" do
 			output = []
 			logger.output_to( output )
@@ -244,6 +284,7 @@ describe Loggability::Logger do
 			expect( messages.first ).to match( expected_format )
 		end
 
+
 		it "has a terse inspection format" do
 			object = Object.new
 			expect(