semantic_logger 2.3.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af5bb50d17c02c2223f455fb8d88aa072bd2a85d
-  data.tar.gz: fe9b9a744c901b75efd79f8facefdce06e0af7ff
+  metadata.gz: 986fd023dd3d5b61817027e25aeae6b6919f65f2
+  data.tar.gz: 7c94accd89688c3ee66fb05c1f17eaba10183abb
 SHA512:
-  metadata.gz: 1ddaf5707fbc254cd56dc1f25eab6e7360bec4678235123935b2911cfd805fc3e9a955c947e718411d64ab04c21fda17d6f87d726568d7b71159a0ab35ca4037
-  data.tar.gz: 51fd7e505173dd2d701cba1daed8566986bf01d4f03584dda000687afc30bd0e7bcb5f14b7c8928927e98ad1bf0616fe37891cd894212d3e403544807653219b
+  metadata.gz: 48eeadcce9890d4d8adb53c8a76c98b259a230f8c7c0c41f3d2ae62ce94bfc850a51c7e6a143064590960aac5e0b12759ec01a396ff9bad93459ecfc81b48778
+  data.tar.gz: ce6a05fe76874b04e2a28bfaf0a09aeb790c9fdc119744dd0b975e22286402a0c62909d67f04fe6d885ed1873397e9b31614528ea285ec696d30a69ab852bafd

data/README.md

@@ -5,13 +5,13 @@ Improved logging for Ruby
 
 * http://github.com/ClarityServices/semantic_logger
 
-### Note:
+## Note:
 
 As of SemanticLogger V2.0 the Rails logging is no longer automatically replaced
 when including SemanticLogger. Include the [rails_semantic_logger](http://github.com/ClarityServices/rails_semantic_logger)
 gem to replace the Rails default logger with SemanticLogger
 
-### Overview
+## Overview
 
 Semantic Logger takes logging in Ruby to a new level by adding several new
 capabilities to the commonly used Logging API:
@@ -132,7 +132,7 @@ Thread Safe
 * Tagged logging keeps any tagging data on a per-thread basis to ensure that
   tags from different threads are not inter-mingled
 
-### Introduction
+## Introduction
 
 Semantic Logger is a Logger that supports logging of meta-data, along with text messages
 to multiple appenders
@@ -183,9 +183,9 @@ Since Semantic Logger can call existing Loggers, it does not force end-users
 to have to adopt a Semantic aware adapter. Although, such adapters create
 tremendous value in the problem monitoring and determination processes.
 
-### Logging API
+## Logging API
 
-#### Standard Logging methods
+### Standard Logging methods
 
 The Semantic Logger logging API supports the existing logging interface for
 the Rails and Ruby Loggers. For example:
@@ -231,7 +231,7 @@ logger.debug("Calling Supplier", :request => 'update', :user => 'Jack')
 logger.debug { "A total of #{result.inject(0) {|sum, i| i+sum }} were processed" }
 ```
 
-### Exceptions
+## Exceptions
 
 The Semantic Logger adds an optional parameter to the existing log methods so that
 a corresponding Exception can be logged in a standard way
@@ -246,7 +246,7 @@ rescue Exception => exception
 end
 ```
 
-#### Payload
+### Payload
 
 The Semantic Logger adds an extra parameter to the existing log methods so that
 additional payload can be logged, such as a Hash or a Ruby Exception object.
@@ -260,7 +260,7 @@ regular expressions so that a program can analyze log output. With the MongoDB
 appender the payload is written directly to MongoDB as part of the document and
 is therefore fully searchable
 
-#### Benchmarking
+### Benchmarking
 
 Another common logging requirement is to measure the time it takes to execute a block
 of code based on the log level. For example:
@@ -317,7 +317,7 @@ Parameters
     Optional, Ruby Exception object to log along with the duration of the supplied block
 ```
 
-#### Logging levels
+### Logging levels
 
 The following logging levels are available through Semantic Logger
 
@@ -336,7 +336,7 @@ in the development environment for low level trace logging of methods calls etc.
 If only the rails logger is being used, then :trace level calls will be logged
 as debug calls only if the log level is set to trace
 
-#### Changing the Class name for Log Entries
+### Changing the Class name for Log Entries
 
 When Semantic Logger is included in a Rails project it automatically replaces the
 loggers for Rails, ActiveRecord::Base, ActionController::Base, and ActiveResource::Base
@@ -375,7 +375,7 @@ This will result in the log output identifying the log entry as from the Externa
 
     2012-08-30 15:37:29.474 I [48308:ScriptThreadProcess: script/rails] (5.2ms) ExternalSupplier -- Calling external interface
 
-#### Tagged Logging
+### Tagged Logging
 
 Semantic Logger allows any Ruby or Rails program to also include tagged logging.
 
@@ -393,7 +393,7 @@ logger.tagged(tracking_number) do
 end
 ```
 
-#### Beyond Tagged Logging
+### Beyond Tagged Logging
 
 Blocks of code can be tagged with not only values, but can be tagged with
 entire hashes of data. The additional hash of data will be merged into
@@ -409,7 +409,7 @@ logger.with_payload(:user => 'Jack', :zip_code => 12345) do
 end
 ```
 
-### Using SemanticLogger
+## Standalone SemanticLogger
 
 When using SemanticLogger inside of Rails all we need to do is include the
 rails_semantic_logger gem and the default Rails logger will be replaced with
@@ -533,17 +533,34 @@ class ExternalSupplier
 end
 ```
 
-### Configuration
+### Logging to Syslog
+
+Log to a local Syslog:
+```ruby
+require 'semantic_logger'
+SemanticLogger.default_level = :trace
+SemanticLogger.add_appender(SemanticLogger::Appender::Syslog.new)
+```
+
+Log to a local file and to a remote Syslog server such as syslog-ng over TCP:
+```ruby
+require 'semantic_logger'
+SemanticLogger.default_level = :trace
+SemanticLogger.add_appender('development.log')
+SemanticLogger.add_appender(SemanticLogger::Appender::Syslog.new(:server => 'tcp://myloghost:514'))
+```
+
+## Configuration
 
 The Semantic Logger follows the principle where multiple appenders can be active
 at the same time. For example, this allows one to log to MongoDB and the Rails
 log file at the same time.
 
-#### Rails Configuration
+### Rails Configuration
 
 To automatically replace the Rails logger with Semantic Logger use the gem [rails_semantic_logger](http://github.com/ClarityServices/rails_semantic_logger)
 
-### Log Struct
+## Log Struct
 
 Internally all log messages are passed around in a Log Struct. In order
 to write your own custom formatter or log appender it is necessary to understand
@@ -589,7 +606,7 @@ level_index [Integer]
 
 * Internal use only. Index of the log level
 
-#### Mixing Logging Levels
+### Mixing Logging Levels
 
 It is sometimes useful to log a subset of the log messages to a separate file
 or appender. For example, log :error and :fatal level messages to a special
@@ -627,7 +644,7 @@ The output is as follows:
 2013-08-02 14:15:56.735273 W [35669:70176909690580] MyClass -- This is a warning message
 ```
 
-#### Custom Formatters
+### Custom Formatters
 
 The formatting for each appender can be replaced with custom code. To replace the
 existing formatter supply a block of code when creating the appender.
@@ -704,21 +721,7 @@ end
 SemanticLogger.add_appender(mongodb_appender)
 ```
 
-### SysLog and other standard loggers
-
-To write log entries to a Syslog logger or any other logger of your choice,
-that conforms the standard Ruby Logger API, Semantic Logger has an Appender to
-use that logger.
-
-For example to configure rails to also log to the Syslogger gem:
-```ruby
-config.after_initialize do
-  # Besides logging to the local file also log to Syslogger
-  config.semantic_logger.appenders << SemanticLogger::Appender::Wrapper.new(Syslogger.new("yourappname"))
-end
-```
-
-### Performance
+## Performance
 
 The traditional logging implementations write their log information to file in the
 same thread of execution as the program itself. This means that for every log entry
@@ -731,12 +734,12 @@ Also, since the logging is in this separate thread there is no impact to program
 execution if we decided to add another appender.
 For example, log to both a file and a MongoDB collection.
 
-### Log Rotation
+## Log Rotation
 
 Since the log file is not re-opened with every call, when the log file needs
 to be rotated, use a copy-truncate operation over deleting the file.
 
-### Why Semantic logging?
+## Why Semantic logging?
 
 Just as there is the initiative to add Semantic information to data on the web
 so that computers can directly understand the content without having to resort
@@ -750,7 +753,7 @@ Once the logging data is in the NOSQL data store it can be queried quickly and
 efficiently. Some SQL data stores also allow complex data types that could be used
 for storing and querying the logging data
 
-### Architecture & Performance
+## Architecture & Performance
 
 In order to ensure that logging does not hinder the performance of the application
 all log entries are written to thread-safe Queue. A separate thread is responsible
@@ -766,7 +769,7 @@ terminates it will call flush on each of the appenders.
 Calling SemanticLogger::Logger#flush will wait until all outstanding log messages
 have been written and flushed to their respective appenders before returning.
 
-### Write your own Appender
+## Write your own Appender
 
 To write your own appender it should meet the following requirements:
 
@@ -821,12 +824,12 @@ instructions below.
 Very Important: New appenders will not be accepted without complete working tests.
 See the [MongoDB Appender Test](https://github.com/ClarityServices/semantic_logger/blob/master/test/appender_mongodb_test.rb) for an example.
 
-### Dependencies
+## Dependencies
 
 - Ruby MRI 1.8.7, 1.9.3 (or above) Or, JRuby 1.6.3 (or above)
 - Optional: To log to MongoDB, Mongo Ruby Driver 1.5.2 or above
 
-### Install
+## Install
 
     gem install semantic_logger
 
@@ -834,7 +837,7 @@ To log to MongoDB, it also needs the Ruby Mongo Driver
 
     gem install mongo
 
-### Future
+## Future
 
 - Add support for a configuration file that can set log level by class name
 - Configuration file to support adding appenders
@@ -850,15 +853,20 @@ Meta
 
 This project uses [Semantic Versioning](http://semver.org/).
 
-Authors
+Author
 -------
 
 Reid Morrison :: reidmo@gmail.com :: @reidmorrison
 
+Contributors
+------------
+
+Marc Bellingrath :: marrrc.b@gmail.com
+
 License
 -------
 
-Copyright 2012,2013 Clarity Services, Inc.
+Copyright 2012,2013 Reid Morrison
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/lib/semantic_logger.rb

@@ -13,5 +13,6 @@ module SemanticLogger
     autoload :File,    'semantic_logger/appender/file'
     autoload :Wrapper, 'semantic_logger/appender/wrapper'
     autoload :MongoDB, 'semantic_logger/appender/mongodb'
+    autoload :Syslog,  'semantic_logger/appender/syslog'
   end
 end

data/lib/semantic_logger/appender/file.rb

@@ -41,22 +41,33 @@ module SemanticLogger
       #
       def initialize(filename, level=nil, &block)
         raise "filename cannot be null when initializing the SemanticLogging::Appender::File" unless filename
-        @filename = filename
         @log = if filename.respond_to?(:write) and filename.respond_to?(:close)
           filename
         else
-          @log = open(filename, (::File::WRONLY | ::File::APPEND | ::File::CREAT))
-          # Force all log entries to write immediately without buffering
-          # Allows multiple processes to write to the same log file simultaneously
-          @log.sync = true
-          @log.set_encoding(Encoding::BINARY) if @log.respond_to?(:set_encoding)
-          @log
+          @filename = filename
+          reopen
         end
 
         # Set the log level and formatter if supplied
         super(level, &block)
       end
 
+      # After forking an active process call #reopen to re-open
+      # open the file handles etc to resources
+      #
+      # Note: This method will only work if a String filename was supplied
+      #       on the initializer.
+      def reopen
+        return unless @filename
+
+        @log = open(@filename, (::File::WRONLY | ::File::APPEND | ::File::CREAT))
+        # Force all log entries to write immediately without buffering
+        # Allows multiple processes to write to the same log file simultaneously
+        @log.sync = true
+        @log.set_encoding(Encoding::BINARY) if @log.respond_to?(:set_encoding)
+        @log
+      end
+
       # Pass log calls to the underlying Rails, log4j or Ruby logger
       #  trace entries are mapped to debug since :trace is not supported by the
       #  Ruby or Rails Loggers

data/lib/semantic_logger/appender/syslog.rb

@@ -0,0 +1,249 @@
+# syslog appender for SemanticLogger - Supports local and remote syslog (over TCP or UDP)
+#
+# Example 1
+# Log to the local syslog.
+#
+# require 'semantic_logger'
+# SemanticLogger.default_level = :trace
+#
+# syslog_appender = SemanticLogger::Appender::Syslog.new
+# SemanticLogger.add_appender(syslog_appender)
+#
+# logger = SemanticLogger['SyslogAppenderExample']
+# logger.info  "Info Hello! - This message should appear in the local syslog!"
+#
+#
+# Example 2
+# Send to a remote syslog appender - myloghost - over TCP on port 514.
+# Tested with syslog-ng as part of an ELSA installation.
+# https://code.google.com/p/enterprise-log-search-and-archive/
+#
+# require 'semantic_logger'
+# # Only log warn and above messages to the remote syslog.
+# syslog_appender = SemanticLogger::Appender::Syslog.new(level: :warn, server: 'tcp://myloghost:514')
+# SemanticLogger.add_appender(syslog_appender)
+#
+# logger = SemanticLogger['SyslogAppenderExample']
+# logger.info  "Info Hello!   - The log level is too low and will not be logged."
+# logger.error "Error! Error! - This message should appear in the remote syslog!"
+#
+require 'syslog'
+require 'uri'
+require 'socket'
+
+module SemanticLogger
+  module Appender
+    class Syslog < SemanticLogger::Appender::Base
+
+      attr_reader :remote_syslog, :server, :host, :port, :protocol, :facility, :local_hostname
+
+      # Default mapping of ruby log levels to syslog log levels
+      #
+      # ::Syslog::LOG_EMERG   - "System is unusable"
+      # ::Syslog::LOG_ALERT   - "Action needs to be taken immediately"
+      # ::Syslog::LOG_CRIT    - "A critical condition has occurred"
+      # ::Syslog::LOG_ERR     - "An error occurred"
+      # ::Syslog::LOG_WARNING - "Warning of a possible problem"
+      # ::Syslog::LOG_NOTICE  - "A normal but significant condition occurred"
+      # ::Syslog::LOG_INFO    - "Informational message"
+      # ::Syslog::LOG_DEBUG   - "Debugging information"
+      DEFAULT_LEVEL_MAP = {
+          :fatal   => ::Syslog::LOG_CRIT,
+          :error   => ::Syslog::LOG_ERR,
+          :warn    => ::Syslog::LOG_WARNING,
+          :info    => ::Syslog::LOG_NOTICE,
+          :debug   => ::Syslog::LOG_INFO,
+          :trace   => ::Syslog::LOG_DEBUG
+      }
+
+      # For more information on the Syslog constants used below see http://ruby-doc.org/stdlib-2.0.0/libdoc/syslog/rdoc/Syslog.html
+      # Parameters
+      #
+      #   :ident [String]
+      #     Identity of the program
+      #     Default: 'ruby'
+      #
+      #   :options [Integer]
+      #     Default: ::Syslog::LOG_PID | ::Syslog::LOG_CONS
+      #     Any of the following (options can be logically OR'd together)
+      #       ::Syslog::LOG_CONS
+      #       ::Syslog::LOG_NDELAY
+      #       ::Syslog::LOG_NOWAIT
+      #       ::Syslog::LOG_ODELAY
+      #       ::Syslog::LOG_PERROR
+      #       ::Syslog::LOG_PID
+      #
+      #   :facility [Integer]
+      #     Default: ::Syslog::LOG_USER
+      #     Type of program (can be logically OR'd together)
+      #       ::Syslog::LOG_AUTH
+      #       ::Syslog::LOG_AUTHPRIV
+      #       ::Syslog::LOG_CONSOLE
+      #       ::Syslog::LOG_CRON
+      #       ::Syslog::LOG_DAEMON
+      #       ::Syslog::LOG_FTP
+      #       ::Syslog::LOG_KERN
+      #       ::Syslog::LOG_LRP
+      #       ::Syslog::LOG_MAIL
+      #       ::Syslog::LOG_NEWS
+      #       ::Syslog::LOG_NTP
+      #       ::Syslog::LOG_SECURITY
+      #       ::Syslog::LOG_SYSLOG
+      #       ::Syslog::LOG_USER
+      #       ::Syslog::LOG_UUCP
+      #       ::Syslog::LOG_LOCAL0
+      #       ::Syslog::LOG_LOCAL1
+      #       ::Syslog::LOG_LOCAL2
+      #       ::Syslog::LOG_LOCAL3
+      #       ::Syslog::LOG_LOCAL4
+      #       ::Syslog::LOG_LOCAL5
+      #       ::Syslog::LOG_LOCAL6
+      #       ::Syslog::LOG_LOCAL7
+      #
+      #   :level [Symbol]
+      #     Default: SemanticLogger's log level.
+      #     The minimum level at which this appender will write logs. Any log messages below this level will be ignored.
+      #
+      #   :level_map [Hash]
+      #     Supply a custom map of SemanticLogger levels to syslog levels.
+      #     For example, passing in { :warn => ::Syslog::LOG_NOTICE }
+      #       would result in a log mapping that matches the default level map,
+      #       except for :warn, which ends up with a LOG_NOTICE level instead of a
+      #       LOG_WARNING one.
+      #     Without overriding any parameters, the level map will be
+      #       LEVEL_MAP = {
+      #         :fatal   => ::Syslog::LOG_CRIT,
+      #         :error   => ::Syslog::LOG_ERR,
+      #         :warn    => ::Syslog::LOG_WARNING,
+      #         :info    => ::Syslog::LOG_NOTICE,
+      #         :debug   => ::Syslog::LOG_INFO,
+      #         :trace   => ::Syslog::LOG_DEBUG
+      #       }
+      #
+      #   :local_hostname [String]
+      #     Default: Socket.gethostname || `hostname`.strip
+      #     Hostname to provide to the remote syslog.
+      #
+      #   :server [String]
+      #     Default: 'syslog://localhost'
+      #     For writing logs to a remote syslog server
+      #     URI of server: protocol://host:port
+      #     Uses port 514 by default for TCP and UDP.
+      #     local syslog example:          'syslog://localhost'
+      #     TCP example with default port: 'tcp://logger'
+      #     TCP example with custom port:  'tcp://logger:8514'
+      #     UDP example with default port: 'udp://logger'
+      #     UDP example with custom port:  'udp://logger:8514'
+      #     When using the :syslog protocol, logs will always be sent to the localhost syslog
+      #
+      #   :tcp_client [Hash]
+      #     Default: {}
+      #     Only used with the TCP protocol.
+      #     Specify custom parameters to pass into ResilientSocket.TCPClient.new
+      #     For a list of options see the resilient_socket documentation:
+      #       https://github.com/reidmorrison/resilient_socket/blob/master/lib/resilient_socket/tcp_client.rb
+      def initialize(params = {}, &block)
+        params = params.dup
+        @ident = params.delete(:ident) || 'ruby'
+        options = params.delete(:options) || (::Syslog::LOG_PID | ::Syslog::LOG_CONS)
+        @facility = params.delete(:facility) || ::Syslog::LOG_USER
+        level = params.delete(:level)
+        level_map = params.delete(:level_map)
+        @level_map = DEFAULT_LEVEL_MAP.dup
+        @level_map.update(level_map) if level_map
+        @server = params.delete(:server) || 'syslog://localhost'
+        uri = URI(@server)
+        @host = uri.host || 'localhost'
+        @protocol = (uri.scheme || :syslog).to_sym
+        raise "Unknown protocol #{@protocol}!" unless [:syslog, :tcp, :udp].include?(@protocol)
+        @host = 'localhost' if @protocol == :syslog
+        @port = URI(@server).port || 514
+        @local_hostname = params.delete(:local_hostname) || Socket.gethostname || `hostname`.strip
+        tcp_client_options = params.delete(:tcp_client)
+
+        # Warn about any unknown configuration options.
+        params.each_pair { |key,val| SemanticLogger::Logger.logger.warn "Ignoring unknown configuration option: #{key.inspect} => #{val.inspect}" }
+
+        # The syslog_protocol gem is required when logging over TCP or UDP.
+        if [:tcp, :udp].include?(@protocol)
+          begin
+            require 'syslog_protocol'
+          rescue LoadError
+            raise 'Missing gem: syslog_protocol. This gem is required when logging over TCP or UDP. To fix this error: gem install syslog_protocol'
+          end
+        end
+
+        case @protocol
+          when :syslog
+            ::Syslog.open(@ident, options, @facility)
+          when :tcp
+            # The resilient_socket gem is required when logging over TCP.
+            begin
+              require 'resilient_socket'
+            rescue LoadError
+              raise 'Missing gem: resilient_socket. This gem is required when logging over TCP. To fix this error: gem install resilient_socket'
+            end
+            options = tcp_client_options || {}
+            options[:server] = "#{@host}:#{@port}"
+            @remote_syslog = ResilientSocket::TCPClient.new(options)
+            # Use the local logger for @remote_syslog so errors with the remote logger can be recorded locally.
+            @remote_syslog.logger = SemanticLogger::Logger.logger
+          when :udp
+            @remote_syslog = UDPSocket.new
+          else
+            raise "Unsupported protocol: #{protocol}"
+        end
+
+        super(level, &block)
+      end
+
+      # Write the log using the specified protocol and host.
+      def log(log)
+        if level_index <= (log.level_index || 0)
+          case @protocol
+            when :syslog
+              ::Syslog.log @level_map[log.level], formatter.call(log)
+            when :tcp
+              @remote_syslog.retry_on_connection_failure { @remote_syslog.write("#{syslog_packet_formatter(log)}\r\n") }
+            when :udp
+              @remote_syslog.send syslog_packet_formatter(log), 0, @host, @port
+            else
+              raise "Unsupported protocol: #{protocol}"
+          end
+        end
+      end
+
+      # Flush is called by the semantic_logger during shutdown.
+      def flush
+        # TODO Add flush for :tcp.
+      end
+
+      # Custom log formatter for syslog
+      def default_formatter
+        Proc.new do |log|
+          tags = log.tags.collect { |tag| "[#{tag}]" }.join(" ") + " " if log.tags && (log.tags.size > 0)
+
+          message = log.message.to_s
+          message << " -- " << log.payload.inspect if log.payload
+          message << " -- " << "#{log.exception.class}: #{log.exception.message}\n#{(log.exception.backtrace || []).join("\n")}" if log.exception
+
+          duration_str = log.duration ? "(#{'%.1f' % log.duration}ms) " : ''
+
+          "#{log.level.to_s[0..0].upcase} [#{$$}:#{log.thread_name}] #{tags}#{duration_str}#{log.name} -- #{message}"
+        end
+      end
+
+      # Format the syslog packet so it can be sent over TCP or UDP
+      def syslog_packet_formatter(log)
+        packet = SyslogProtocol::Packet.new
+        packet.hostname = @local_hostname
+        packet.facility = @facility
+        packet.severity =  @level_map[log.level]
+        packet.tag = @ident
+        packet.content = default_formatter.call(log)
+        packet.to_s
+      end
+
+    end
+  end
+end

data/lib/semantic_logger/semantic_logger.rb

@@ -122,6 +122,14 @@ module SemanticLogger
     SemanticLogger::Logger.flush
   end
 
+  # After forking an active process call SemanticLogger.reopen to re-open
+  # any open file handles etc to resources
+  #
+  # Note: Only appenders that implement the reopen method will be called
+  def self.reopen
+    @@appenders.each {|appender| appender.reopen if appender.respond_to?(:reopen)}
+  end
+
   ############################################################################
   protected
 

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = "2.3.1"
+  VERSION = "2.4.0"
 end

data/test/appender_syslog_test.rb

@@ -0,0 +1,50 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha/setup'
+require 'semantic_logger'
+require 'socket'
+require 'resilient_socket'
+require 'syslog_protocol'
+
+# Unit Test for SemanticLogger::Appender::Syslog
+#
+class AppenderSyslogTest < Test::Unit::TestCase
+  context SemanticLogger::Appender::Syslog do
+
+    should 'handle local syslog' do
+      ::Syslog.expects(:open).once
+      ::Syslog.expects(:log).once
+      syslog_appender = SemanticLogger::Appender::Syslog.new
+      syslog_appender.debug 'AppenderSyslogTest log message'
+    end
+
+    should 'handle remote syslog over TCP' do
+      ::ResilientSocket::TCPClient.any_instance.stubs('closed?').returns(false)
+      ::ResilientSocket::TCPClient.any_instance.stubs('connect')
+      ::ResilientSocket::TCPClient.any_instance.expects(:write).with{ |message| message =~ /<70>(.*?)SemanticLogger::Appender::Syslog -- AppenderSyslogTest log message\r\n/ }
+      syslog_appender = SemanticLogger::Appender::Syslog.new(:server => 'tcp://localhost:88888')
+      syslog_appender.debug 'AppenderSyslogTest log message'
+    end
+
+    should 'handle remote syslog over UDP' do
+      ::UDPSocket.any_instance.expects(:send).with{ |*params| params[0] =~ /<70>(.*?)SemanticLogger::Appender::Syslog -- AppenderSyslogTest log message/ }
+      syslog_appender = SemanticLogger::Appender::Syslog.new(:server => 'udp://localhost:88888')
+      syslog_appender.debug 'AppenderSyslogTest log message'
+    end
+
+    # Should be able to log each level.
+    SemanticLogger::LEVELS.each do |level|
+      should "log #{level} information" do
+        ::Syslog.expects(:open).once
+        ::Syslog.expects(:log).once
+        syslog_appender = SemanticLogger::Appender::Syslog.new
+        syslog_appender.send(level, 'AppenderSyslogTest #{level.to_s} message')
+      end
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-24 00:00:00.000000000 Z
+date: 2013-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sync_attr
@@ -49,6 +49,7 @@ files:
 - lib/semantic_logger/appender/base.rb
 - lib/semantic_logger/appender/file.rb
 - lib/semantic_logger/appender/mongodb.rb
+- lib/semantic_logger/appender/syslog.rb
 - lib/semantic_logger/appender/wrapper.rb
 - lib/semantic_logger/base.rb
 - lib/semantic_logger/loggable.rb
@@ -61,6 +62,7 @@ files:
 - README.md
 - test/appender_file_test.rb
 - test/appender_mongodb_test.rb
+- test/appender_syslog_test.rb
 - test/appender_wrapper_test.rb
 - test/loggable_test.rb
 - test/logger_test.rb
@@ -92,6 +94,7 @@ summary: Improved logging for Ruby
 test_files:
 - test/appender_file_test.rb
 - test/appender_mongodb_test.rb
+- test/appender_syslog_test.rb
 - test/appender_wrapper_test.rb
 - test/loggable_test.rb
 - test/logger_test.rb