semantic_logger 2.8.0 → 2.9.0

data/lib/semantic_logger.rb

@@ -3,16 +3,17 @@ require 'semantic_logger/version'
 require 'semantic_logger/semantic_logger'
 
 module SemanticLogger
-  autoload :Base,      'semantic_logger/base'
-  autoload :Logger,    'semantic_logger/logger'
-  autoload :Loggable,  'semantic_logger/loggable'
+  autoload :Base,       'semantic_logger/base'
+  autoload :Logger,     'semantic_logger/logger'
+  autoload :Loggable,   'semantic_logger/loggable'
 
   module Appender
-    autoload :Base,    'semantic_logger/appender/base'
-    autoload :File,    'semantic_logger/appender/file'
-    autoload :Wrapper, 'semantic_logger/appender/wrapper'
-    autoload :MongoDB, 'semantic_logger/appender/mongodb'
-    autoload :Syslog,  'semantic_logger/appender/syslog'
+    autoload :Base,     'semantic_logger/appender/base'
+    autoload :File,     'semantic_logger/appender/file'
+    autoload :Wrapper,  'semantic_logger/appender/wrapper'
+    autoload :MongoDB,  'semantic_logger/appender/mongodb'
+    autoload :Syslog,   'semantic_logger/appender/syslog'
+    autoload :NewRelic, 'semantic_logger/appender/new_relic'
   end
 end
 

data/lib/semantic_logger/appender/base.rb

@@ -77,6 +77,10 @@ module SemanticLogger
         end
       end
 
+      def flush
+        # An appender can implement a flush method if it supports it.
+      end
+
       ############################################################################
       protected
 

data/lib/semantic_logger/appender/mongodb.rb

@@ -141,7 +141,7 @@ module SemanticLogger
           document = {
             :time        => log.time,
             :host_name   => host_name,
-            :pid         => $PID,
+            :pid         => $$,
             :thread_name => log.thread_name,
             :name        => log.name,
             :level       => log.level,

data/lib/semantic_logger/appender/new_relic.rb

@@ -0,0 +1,105 @@
+=begin
+New Relic appender for SemanticLogger
+
+The :error and :fatal log entries will show up under Applications > "Application Name" > Events > Errors in New Relic
+
+Note: Payload information is not filtered, so take care not to push any sensitive information when logging with tags or a payload.
+
+
+Example 1
+
+Adding the New Relic appender will send :error and :fatal log entries to New Relic as error events.
+
+For a Rails application already configured to use SemanticLogger and New Relic, create a file called <Rails Root>/config/initializers/newrelic_appender.rb with the following contents and restart the application:
+
+# Send :error and :fatal log messages to New Relic
+SemanticLogger.add_appender(SemanticLogger::Appender::NewRelic.new)
+Rails.logger.info 'SemanticLogger New Relic Appender added.'
+
+
+Example 2
+
+For a non-Rails application, send :info and more severe log entries to a file called application.log and also send :error and :fatal log entries to New Relic.
+
+# ./newrelic.yml needs to be set up -- see https://docs.newrelic.com/docs/ruby/ruby-agent-installation for more information.
+
+require 'semantic_logger'
+require 'newrelic_rpm'
+
+# New Relic setup
+NewRelic::Agent.manual_start
+
+# SemanticLogger setup
+SemanticLogger.default_level = :info
+SemanticLogger.add_appender('application.log')
+SemanticLogger.add_appender(SemanticLogger::Appender::NewRelic.new)
+logger = SemanticLogger['Example']
+
+# Log some messages
+logger.info  'This is only written to application.log'
+logger.error 'This is written to application.log and will also be sent to New Relic as an error event'
+
+# The appender will send tags, payloads and benchmark duration to New Relic
+logger.tagged('test') do
+  logger.with_payload( {key1: 123, key2: 'abc'} ) do
+    logger.benchmark_error(@message) do
+      sleep 0.001
+    end
+  end
+end
+
+# New Relic does not seem to receive any errors if the application exits too soon after sending error alerts.
+sleep 10
+
+# New Relic shutdown - should send any queued data before exiting
+::NewRelic::Agent.shutdown
+=end
+
+
+require 'newrelic_rpm'
+
+class SemanticLogger::Appender::NewRelic < SemanticLogger::Appender::Base
+
+  # Allow the level for this appender to be overwritten
+  #   Default: :error
+  #   Note: Not recommended to set the log level to :info, :debug, or :trace as that would flood NewRelic with Error notices
+  def initialize(level=:error,&block)
+    # Pass on the level and custom formatter if supplied
+    super(level, &block)
+  end
+
+  # The application may send a multiline string to the appender... use the first non-blank line as a shorter message.
+  def self.first_non_empty_line(string)
+    string.strip.split("\n").first.to_s
+  end
+
+  # Returns [Hash] of parameters to send to New Relic.
+  def default_formatter
+    Proc.new do |log|
+      short_message = self.class.first_non_empty_line(log.message)
+      metric = log.metric || "#{log.name}/#{short_message}"
+
+      custom_params = { :thread_name => log.thread_name }
+      # Only show the message under custom attributes if the error message uses an exception or shortened message (first non-empty line).
+      custom_params[:message]  = log.message  if log.message && (log.exception || log.message != short_message)
+      custom_params[:duration] = "#{log.duration} ms" if log.duration
+      custom_params[:payload]  = log.payload  if log.payload
+      custom_params[:tags]     = log.tags     if log.tags && (log.tags.size > 0)
+
+      { :metric => metric, :custom_params => custom_params }
+    end
+  end
+
+  # Send an error notification to New Relic
+  def log(log)
+    # Ensure minimum log level is met.
+    return false unless level_index <= (log.level_index || 0)
+
+    # For more documentation on the NewRelic::Agent.notice_error method see:
+    # http://rubydoc.info/github/newrelic/rpm/NewRelic/Agent#notice_error-instance_method
+    # and https://docs.newrelic.com/docs/ruby/ruby-agent-api
+    NewRelic::Agent.notice_error(log.exception || self.class.first_non_empty_line(log.message), formatter.call(log))
+    return true
+  end
+
+end

data/lib/semantic_logger/base.rb

@@ -18,7 +18,7 @@ module SemanticLogger
     #   SemanticLogger.default_level
     #
     # Must be one of the values in SemanticLogger::LEVELS, or
-    # nil if this logger instance should use the global default log_level
+    # nil if this logger instance should use the global default level
     def level=(level)
       @level_index = SemanticLogger.level_to_index(level)
       @level = level
@@ -263,6 +263,9 @@ module SemanticLogger
     # level_index
     #   Internal index of the log level
     #
+    # exception
+    #   Ruby Exception object to log
+    #
     # metric [Object]
     #   Object supplied when benchmark_x was called
     Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception, :metric)

data/lib/semantic_logger/semantic_logger.rb

@@ -47,9 +47,9 @@ module SemanticLogger
   #     Ruby built-in Logger, or any logger that implements the following methods:
   #       :debug, :info, :warn, :error, :fatal
   #
-  #   log_level [Symbol]
+  #   level [Symbol]
   #     Optional
-  #     By setting the log_level higher than the SemanticLogger::default_level
+  #     By setting the level higher than the SemanticLogger::default_level
   #     this appender can exclude lower level log messages
   #     Any one of SemanticLogger::LEVELS. For example: :trace, :debug, :info, :warn, :error, :fatal
   #
@@ -82,13 +82,13 @@ module SemanticLogger
   #   logger.info "Hello World"
   #   logger.debug("Login time", :user => 'Joe', :duration => 100, :ip_address=>'127.0.0.1')
   #
-  def self.add_appender(appender, log_level=nil, &block)
+  def self.add_appender(appender, level=nil, &block)
     appender_instance = if appender.is_a?(String) || appender.is_a?(IO)
       # $stderr, STDOUT, other IO, or a filename
-      SemanticLogger::Appender::File.new(appender, log_level, &block)
+      SemanticLogger::Appender::File.new(appender, level, &block)
     elsif appender.is_a? Appender::Base
       # Already an instance of an appender
-      appender.log_level = log_level if log_level
+      appender.level = level if level
       appender.formatter = block if block
       appender
     else
@@ -97,7 +97,7 @@ module SemanticLogger
         raise "Supplied appender does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}"
       end
 
-      raise "Change the log level to #{log_level}, update the log level directly against the supplied appender" if log_level
+      raise "Change the log level to #{level}, update the log level directly against the supplied appender" if level
       SemanticLogger::Appender::Wrapper.new(appender, &block)
     end
     @@appenders << appender_instance
@@ -192,7 +192,7 @@ module SemanticLogger
   # Also supports mapping the ::Logger levels to SemanticLogger levels
   def self.level_to_index(level)
     return if level.nil?
-    
+
     index = if level.is_a?(Symbol)
       LEVELS.index(level)
     elsif level.is_a?(String)
@@ -216,4 +216,4 @@ module SemanticLogger
   # Initial default Level for all new instances of SemanticLogger::Logger
   @@default_level = :info
   @@default_level_index = level_to_index(@@default_level)
-end
+end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = "2.8.0"
+  VERSION = "2.9.0"
 end

data/test/appender_mongodb_test.rb

@@ -37,7 +37,7 @@ class AppenderMongoDBTest < Test::Unit::TestCase
         assert_equal nil, document['thread_name']
         assert_equal nil, document['time']
         assert_equal nil, document['payload']
-        assert_equal $PID, document['pid']
+        assert_equal $$, document['pid']
         assert_equal 'test', document['host_name']
         assert_equal 'test_application', document['application']
       end
@@ -53,7 +53,7 @@ class AppenderMongoDBTest < Test::Unit::TestCase
         assert_equal nil, document['thread_name']
         assert_equal nil, document['time']
         assert_equal({ "tracking_number" => 12345, "session_id" => 'HSSKLEU@JDK767'}, document['payload'])
-        assert_equal $PID, document['pid']
+        assert_equal $$, document['pid']
         assert_equal 'test', document['host_name']
         assert_equal 'test_application', document['application']
       end
@@ -72,7 +72,7 @@ class AppenderMongoDBTest < Test::Unit::TestCase
         assert_equal 'thread', document['thread_name']
         assert_equal @time.to_i, document['time'].to_i
         assert_equal({ "tracking_number" => 12345, "session_id" => 'HSSKLEU@JDK767'}, document['payload'])
-        assert_equal $PID, document['pid']
+        assert_equal $$, document['pid']
         assert_equal 'test', document['host_name']
         assert_equal 'test_application', document['application']
       end
@@ -90,7 +90,7 @@ class AppenderMongoDBTest < Test::Unit::TestCase
         assert_equal 'thread', document['thread_name']
         assert_equal @time.to_i, document['time'].to_i
         assert_equal nil, document['payload']
-        assert_equal $PID, document['pid']
+        assert_equal $$, document['pid']
         assert_equal 'test', document['host_name']
         assert_equal 'test_application', document['application']
       end
@@ -107,7 +107,7 @@ class AppenderMongoDBTest < Test::Unit::TestCase
           assert_equal 'thread', document['thread_name']
           assert_equal @time.to_i, document['time'].to_i
           assert_equal({ "tracking_number" => 12345, "session_id" => 'HSSKLEU@JDK767'}, document['payload'])
-          assert_equal $PID, document['pid']
+          assert_equal $$, document['pid']
           assert_equal 'test', document['host_name']
           assert_equal 'test_application', document['application']
         end

data/test/appender_new_relic_test.rb

@@ -0,0 +1,79 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+# Load mocked newrelic_rpm from test directory
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha/setup'
+require 'semantic_logger'
+
+# Unit Test for SemanticLogger::Appender::NewRelic
+#
+class AppenderNewRelicTest < Test::Unit::TestCase
+  context SemanticLogger::Appender::NewRelic do
+
+    setup do
+      @appender = SemanticLogger::Appender::NewRelic.new
+      @message  = 'AppenderNewRelicTest log message'
+      @multi_line_message = <<-EOSTR
+
+
+      first non-blank line
+      second non-blank line
+
+      third non-blank line
+
+      EOSTR
+    end
+
+    (SemanticLogger::LEVELS - [:error, :fatal]).each do |level|
+      should "not send :#{level.to_s} notifications to New Relic" do
+        @appender.tagged('test') do
+          @appender.send(level, "AppenderNewRelicTest #{level.to_s} message")
+        end
+        assert_nil ::NewRelic::Agent.message
+        assert_nil ::NewRelic::Agent.hash, ::NewRelic::Agent.hash
+      end
+    end
+
+    [:error, :fatal].each do |level|
+      should "send :#{level.to_s} notifications to New Relic" do
+      @appender.tagged('test') do
+        @appender.send(level, @message)
+      end
+      assert_equal @message, ::NewRelic::Agent.message
+      assert_equal ['test'], ::NewRelic::Agent.hash[:custom_params][:tags], ::NewRelic::Agent.hash
+      assert_equal "SemanticLogger::Appender::NewRelic/#{@message}", ::NewRelic::Agent.hash[:metric]
+      assert_nil ::NewRelic::Agent.hash[:custom_params][:duration], ::NewRelic::Agent.hash
+      assert_not_nil ::NewRelic::Agent.hash[:custom_params][:thread_name], ::NewRelic::Agent.hash
+      end
+    end
+
+    should 'send notification to New Relic with custom attributes' do
+      @appender.tagged('test') do
+        @appender.with_payload({:key1 => 1, :key2 => 'a'}) do
+          @appender.benchmark(:error, @message) do
+            sleep 0.001
+          end
+        end
+      end
+      assert_equal @message, ::NewRelic::Agent.message
+      assert_equal ['test'], ::NewRelic::Agent.hash[:custom_params][:tags], ::NewRelic::Agent.hash
+      assert_equal "SemanticLogger::Appender::NewRelic/#{@message}", ::NewRelic::Agent.hash[:metric]
+      assert_equal({:key1 => 1, :key2 => 'a'}, ::NewRelic::Agent.hash[:custom_params][:payload], ::NewRelic::Agent.hash)
+      assert_not_nil ::NewRelic::Agent.hash[:custom_params][:duration], ::NewRelic::Agent.hash
+      assert_not_nil ::NewRelic::Agent.hash[:custom_params][:thread_name], ::NewRelic::Agent.hash
+    end
+
+    should 'use the first non-blank line for a multi-line message' do
+      @appender.tagged('test') do
+        @appender.error @multi_line_message
+      end
+      assert_equal 'first non-blank line', ::NewRelic::Agent.message
+    end
+
+  end
+end

data/test/newrelic_rpm.rb

@@ -0,0 +1,21 @@
+# Mocked NewRelic::Agent used for testing
+
+module NewRelic
+  module Agent
+    @@message = nil
+    @@hash = nil
+
+    def self.notice_error(message, hash)
+      @@message = message
+      @@hash = hash
+    end
+
+    def self.message
+      @@message
+    end
+
+    def self.hash
+      @@hash
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 2.8.0
+  version: 2.9.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-21 00:00:00.000000000 Z
+date: 2014-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sync_attr
@@ -38,8 +38,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.0
-description: Semantic Logger takes logging in Ruby to the next level by adding several
-  new capabilities to the commonly used Logging API
+description: Next generation logging system for Ruby to support highly concurrent,
+  high throughput, low latency systems
 email:
 - reidmo@gmail.com
 executables: []
@@ -53,6 +53,7 @@ files:
 - lib/semantic_logger/appender/base.rb
 - lib/semantic_logger/appender/file.rb
 - lib/semantic_logger/appender/mongodb.rb
+- lib/semantic_logger/appender/new_relic.rb
 - lib/semantic_logger/appender/syslog.rb
 - lib/semantic_logger/appender/wrapper.rb
 - lib/semantic_logger/base.rb
@@ -63,11 +64,13 @@ files:
 - lib/semantic_logger/version.rb
 - test/appender_file_test.rb
 - test/appender_mongodb_test.rb
+- test/appender_new_relic_test.rb
 - test/appender_syslog_test.rb
 - test/appender_wrapper_test.rb
 - test/loggable_test.rb
 - test/logger_test.rb
 - test/mock_logger.rb
+- test/newrelic_rpm.rb
 homepage: https://github.com/reidmorrison/semantic_logger
 licenses:
 - Apache License V2.0
@@ -95,8 +98,10 @@ summary: Scalable, next generation logging for Ruby
 test_files:
 - test/appender_file_test.rb
 - test/appender_mongodb_test.rb
+- test/appender_new_relic_test.rb
 - test/appender_syslog_test.rb
 - test/appender_wrapper_test.rb
 - test/loggable_test.rb
 - test/logger_test.rb
 - test/mock_logger.rb
+- test/newrelic_rpm.rb