semantic_logger 4.6.1 → 4.10.0

data/lib/semantic_logger/appender/rabbitmq.rb

@@ -1,7 +1,7 @@
 begin
-  require 'bunny'
+  require "bunny"
 rescue LoadError
-  raise LoadError.new('Gem bunny is required for logging to RabbitMQ. Please add the gem "bunny" to your Gemfile.')
+  raise LoadError, 'Gem bunny is required for logging to RabbitMQ. Please add the gem "bunny" to your Gemfile.'
 end
 
 # Forward all log messages to RabbitMQ.
@@ -14,7 +14,7 @@ end
 #     # Name of the queue in RabbitMQ where to publish the logs. This queue will be bound to "amqp.direct" exchange.
 #     queue: 'semantic_logger',
 #
-#     # This host will be used for RabbitMQ connection. 
+#     # This host will be used for RabbitMQ connection.
 #     # NOTE this is different than :host option which is used by the logger directly.
 #     rabbitmq_host: '127.0.0.1',
 #
@@ -63,7 +63,7 @@ module SemanticLogger
       # RabbitMQ Parameters:
       #
       #   rabbitmq_host: [String]
-      #     Host for AMQP connection. in Bunny this is called :host but here it has 
+      #     Host for AMQP connection. in Bunny this is called :host but here it has
       #     been remapped to avoid conflicting with SemanticLogger's :host param.
       #     Default: localhost
       #
@@ -76,7 +76,7 @@ module SemanticLogger
       #     Default: nil
       #
       #   more parameters supported by Bunny: http://rubybunny.info/articles/connecting.html
-      def initialize(queue_name: 'semantic_logger', rabbitmq_host: nil, metrics: false, **args, &block)
+      def initialize(queue_name: "semantic_logger", rabbitmq_host: nil, metrics: false, **args, &block)
         @queue_name             = queue_name
         @rabbitmq_args          = args.dup
         @rabbitmq_args[:host]   = rabbitmq_host

data/lib/semantic_logger/appender/sentry.rb

@@ -1,7 +1,7 @@
 begin
-  require 'sentry-raven'
+  require "sentry-raven"
 rescue LoadError
-  raise LoadError.new('Gem sentry-raven is required for logging purposes. Please add the gem "sentry-raven" to your Gemfile.')
+  raise LoadError, 'Gem sentry-raven is required for logging purposes. Please add the gem "sentry-raven" to your Gemfile.'
 end
 
 # Send log messages to sentry
@@ -46,12 +46,12 @@ module SemanticLogger
       # Send an error notification to sentry
       def log(log)
         # Ignore logs coming from Raven itself
-        return false if log.name == 'Raven'
+        return false if log.name == "Raven"
 
-        context = formatter.call(log, self)
-        user = context.delete(:user)
-        tags = context.delete(:tags)
-        attrs = {
+        context      = formatter.call(log, self)
+        user         = context.delete(:user)
+        tags         = context.delete(:tags)
+        attrs        = {
           level: context.delete(:level),
           extra: context
         }

data/lib/semantic_logger/appender/sentry_ruby.rb

@@ -0,0 +1,138 @@
+begin
+  require "sentry-ruby"
+rescue LoadError
+  raise LoadError, 'Gem sentry-ruby is required for logging purposes. Please add the gem "sentry-ruby" to your Gemfile.'
+end
+
+# Send log messages to sentry
+#
+# Example:
+#   SemanticLogger.add_appender(appender: :sentry_ruby)
+#
+module SemanticLogger
+  module Appender
+    class SentryRuby < SemanticLogger::Subscriber
+      # Create Appender
+      #
+      # Parameters
+      #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+      #     Override the log level for this appender.
+      #     Default: :error
+      #
+      #   formatter: [Object|Proc|Symbol|Hash]
+      #     An instance of a class that implements #call, or a Proc to be used to format
+      #     the output from this appender
+      #     Default: Use the built-in formatter (See: #call)
+      #
+      #   filter: [Regexp|Proc]
+      #     RegExp: Only include log messages where the class name matches the supplied.
+      #     regular expression. All other messages will be ignored.
+      #     Proc: Only include log messages where the supplied Proc returns true
+      #           The Proc must return true or false.
+      #
+      #   host: [String]
+      #     Name of this host to appear in log messages.
+      #     Default: SemanticLogger.host
+      #
+      #   application: [String]
+      #     Name of this application to appear in log messages.
+      #     Default: SemanticLogger.application
+      def initialize(level: :error, **args, &block)
+        # Replace the Sentry Ruby logger so that we can identify its log
+        # messages and not forward them to Sentry
+        ::Sentry.init { |config| config.logger = SemanticLogger[::Sentry] }
+        super(level: level, **args, &block)
+      end
+
+      # Send an error notification to sentry
+      def log(log)
+        # Ignore logs coming from Sentry itself
+        return false if log.name == "Sentry"
+
+        context = formatter.call(log, self)
+        payload = context.delete(:payload) || {}
+        named_tags = context[:named_tags] || {}
+        transaction_name = named_tags.delete(:transaction_name)
+
+        user = extract_user!(named_tags, payload)
+        tags = extract_tags!(context)
+
+        fingerprint = payload.delete(:fingerprint)
+
+        ::Sentry.with_scope do |scope|
+          scope.set_user(user) if user
+          scope.set_level(context.delete(:level)) if context[:level]
+          scope.set_fingerprint(fingerprint) if fingerprint
+          scope.set_transaction_name(transaction_name) if transaction_name
+          scope.set_tags(tags)
+          scope.set_extras(context)
+          scope.set_extras(payload)
+
+          if log.exception
+            ::Sentry.capture_exception(log.exception)
+          elsif log.backtrace
+            ::Sentry.capture_message(context[:message], backtrace: log.backtrace)
+          else
+            ::Sentry.capture_message(context[:message])
+          end
+        end
+
+        true
+      end
+
+      private
+
+      # Use Raw Formatter by default
+      def default_formatter
+        SemanticLogger::Formatters::Raw.new
+      end
+
+      # Extract user data from named tags or payload.
+      #
+      # Keys :user_id and :user_email will be used as :id and :email respectively.
+      # Keys :username and :ip_address will be used verbatim.
+      #
+      # Any additional value nested in a :user key will be added, provided any of
+      # the above keys is already present.
+      #
+      def extract_user!(*sources)
+        keys = {user_id: :id, username: :username, user_email: :email, ip_address: :ip_address}
+
+        user = {}
+
+        sources.each do |source|
+          keys.each do |source_key, target_key|
+            value = source.delete(source_key)
+            user[target_key] = value if value
+          end
+        end
+
+        return if user.empty?
+
+        sources.each do |source|
+          extras = source.delete(:user)
+          user.merge!(extras) if extras.is_a?(Hash)
+        end
+
+        user
+      end
+
+      # Extract tags.
+      #
+      # Named tags will be stringified (both key and value).
+      # Unnamed tags will be stringified and joined with a comma. Then they will
+      # be used as a "tag" named tag. If such a tag already exists, it is also
+      # joined with a comma.
+      #
+      # Finally, the tag names are limited to 32 characters and the tag values to 256.
+      #
+      def extract_tags!(context)
+        named_tags = context.delete(:named_tags) || {}
+        named_tags = named_tags.map { |k, v| [k.to_s, v.to_s] }.to_h
+        tags = context.delete(:tags)
+        named_tags.merge!("tag" => tags.join(", ")) { |_, v1, v2| "#{v1}, #{v2}" } if tags
+        named_tags.map { |k, v| [k[0...32], v[0...256]] }.to_h
+      end
+    end
+  end
+end

data/lib/semantic_logger/appender/splunk.rb

@@ -1,7 +1,8 @@
 begin
-  require 'splunk-sdk-ruby'
+  require "splunk-sdk-ruby"
 rescue LoadError
-  raise LoadError.new('Gem splunk-sdk-ruby is required for logging to Splunk. Please add the gem "splunk-sdk-ruby" to your Gemfile.')
+  raise LoadError,
+        'Gem splunk-sdk-ruby is required for logging to Splunk. Please add the gem "splunk-sdk-ruby" to your Gemfile.'
 end
 
 # Splunk log appender.
@@ -88,7 +89,7 @@ module SemanticLogger
       #     regular expression. All other messages will be ignored.
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
-      def initialize(index: 'main', source_type: nil, **args, &block)
+      def initialize(index: "main", source_type: nil, **args, &block)
         @index       = index
         @source_type = source_type
 
@@ -120,7 +121,7 @@ module SemanticLogger
       def call(log, logger)
         h = SemanticLogger::Formatters::Raw.new.call(log, logger)
         h.delete(:time)
-        message               = {
+        message = {
           source:  logger.application,
           host:    logger.host,
           time:    log.time.utc.to_f,
@@ -128,7 +129,7 @@ module SemanticLogger
           event:   h
         }
         message[:environment] = logger.environment if logger.environment
-        message[:sourcetype] = source_type if source_type
+        message[:sourcetype]  = source_type if source_type
         message
       end
     end

data/lib/semantic_logger/appender/splunk_http.rb

@@ -1,4 +1,4 @@
-require 'json'
+require "json"
 # Splunk log appender using the Splunk HTTP(S) listener.
 #
 # Use the newer, faster and more complete JSON over HTTP interface for Splunk.
@@ -81,22 +81,22 @@ module SemanticLogger
         super(compress: compress, **args, &block)
 
         # Put splunk auth token in the header of every HTTP post.
-        @header['Authorization'] = "Splunk #{token}"
+        @header["Authorization"] = "Splunk #{token}"
       end
 
       # Returns [String] JSON to send to Splunk.
       #
       # For splunk format requirements see:
-      #   http://dev.splunk.com/view/event-collector/SP-CAAAE6P
+      #   https://docs.splunk.com/Documentation/Splunk/latest/Data/FormateventsforHTTPEventCollector
       def call(log, logger)
-        h                     = SemanticLogger::Formatters::Raw.new(time_format: :seconds).call(log, logger)
-        message               = {
+        h = SemanticLogger::Formatters::Raw.new(time_format: :seconds).call(log, logger)
+        h.delete(:host)
+        message = {
           source: logger.application,
           host:   logger.host,
           time:   h.delete(:time),
           event:  h
         }
-        message[:environment] = logger.environment if logger.environment
         message[:sourcetype]  = source_type if source_type
         message[:index]       = index if index
         message.to_json

data/lib/semantic_logger/appender/syslog.rb

@@ -1,6 +1,6 @@
-require 'syslog'
-require 'uri'
-require 'socket'
+require "syslog"
+require "uri"
+require "socket"
 # Send log messages to local syslog, or remote syslog servers over TCP or UDP.
 #
 # Example:
@@ -31,7 +31,7 @@ require 'socket'
 module SemanticLogger
   module Appender
     class Syslog < SemanticLogger::Subscriber
-      attr_reader :remote_syslog, :url, :server, :port, :protocol, :facility, :options, :level_map
+      attr_reader :remote_syslog, :url, :server, :port, :protocol, :facility, :options, :level_map, :max_size
 
       # Create a Syslog appender instance.
       #
@@ -57,7 +57,7 @@ module SemanticLogger
       #     Only used with the TCP protocol.
       #     Specify custom parameters to pass into Net::TCPClient.new
       #     For a list of options see the net_tcp_client documentation:
-      #       https://github.com/rocketjob/net_tcp_client/blob/master/lib/net/tcp_client/tcp_client.rb
+      #       https://github.com/reidmorrison/net_tcp_client/blob/master/lib/net/tcp_client/tcp_client.rb
       #
       #   level: [:trace | :debug | :info | :warn | :error | :fatal]
       #     Override the log level for this appender.
@@ -73,6 +73,10 @@ module SemanticLogger
       #     Identity of the program.
       #     Default: SemanticLogger.application
       #
+      #   max_size: [Integer]
+      #     Set your own packet size.
+      #     Default: 1024 bytes
+      #
       #   options: [Integer]
       #     Default: ::Syslog::LOG_PID | ::Syslog::LOG_CONS
       #     Any of the following (options can be logically OR'd together)
@@ -119,8 +123,9 @@ module SemanticLogger
       #   Example:
       #     # Change the warn level to LOG_NOTICE level instead of a the default of LOG_WARNING.
       #     SemanticLogger.add_appender(appender: :syslog, level_map: {warn: ::Syslog::LOG_NOTICE})
-      def initialize(url: 'syslog://localhost',
+      def initialize(url: "syslog://localhost",
                      facility: ::Syslog::LOG_USER,
+                     max_size: 1024,
                      level_map: SemanticLogger::Formatters::Syslog::LevelMap.new,
                      options: ::Syslog::LOG_PID | ::Syslog::LOG_CONS,
                      tcp_client: {},
@@ -129,13 +134,14 @@ module SemanticLogger
 
         @options            = options
         @facility           = facility
+        @max_size           = max_size
         @level_map          = level_map
         @url                = url
         uri                 = URI(@url)
-        @server             = uri.host || 'localhost'
+        @server             = uri.host || "localhost"
         @protocol           = (uri.scheme || :syslog).to_sym
         @port               = uri.port || 514
-        @server             = 'localhost' if @protocol == :syslog
+        @server             = "localhost" if @protocol == :syslog
         @tcp_client_options = tcp_client
 
         raise "Unknown protocol #{@protocol}!" unless %i[syslog tcp udp].include?(@protocol)
@@ -143,17 +149,19 @@ module SemanticLogger
         # The syslog_protocol gem is required when logging over TCP or UDP.
         if %i[tcp udp].include?(@protocol)
           begin
-            require 'syslog_protocol'
+            require "syslog_protocol"
           rescue LoadError
-            raise LoadError.new('Missing gem: syslog_protocol. This gem is required when logging over TCP or UDP. To fix this error: gem install syslog_protocol')
+            raise LoadError,
+                  "Missing gem: syslog_protocol. This gem is required when logging over TCP or UDP. To fix this error: gem install syslog_protocol"
           end
 
           # The net_tcp_client gem is required when logging over TCP.
           if protocol == :tcp
             begin
-              require 'net/tcp_client'
+              require "net/tcp_client"
             rescue LoadError
-              raise LoadError.new('Missing gem: net_tcp_client. This gem is required when logging over TCP. To fix this error: gem install net_tcp_client')
+              raise LoadError,
+                    "Missing gem: net_tcp_client. This gem is required when logging over TCP. To fix this error: gem install net_tcp_client"
             end
           end
         end
@@ -171,7 +179,7 @@ module SemanticLogger
           ::Syslog.send(method, application, options, facility)
         when :tcp
           @tcp_client_options[:server] = "#{@server}:#{@port}"
-          @remote_syslog               = Net::TCPClient.new(@tcp_client_options)
+          @remote_syslog               = Net::TCPClient.new(**@tcp_client_options)
           # Use the local logger for @remote_syslog so errors with the remote logger can be recorded locally.
           @remote_syslog.logger = logger
         when :udp
@@ -186,7 +194,7 @@ module SemanticLogger
         case @protocol
         when :syslog
           # Since the Ruby Syslog API supports sprintf format strings, double up all existing '%'
-          message = formatter.call(log, self).gsub '%', '%%'
+          message = formatter.call(log, self).gsub "%", "%%"
           ::Syslog.log @level_map[log.level], message
         when :tcp
           @remote_syslog.retry_on_connection_failure { @remote_syslog.write("#{formatter.call(log, self)}\r\n") }
@@ -209,7 +217,7 @@ module SemanticLogger
           # Format is text output without the time
           SemanticLogger::Formatters::Default.new(time_format: nil)
         else
-          SemanticLogger::Formatters::Syslog.new(facility: facility, level_map: level_map)
+          SemanticLogger::Formatters::Syslog.new(facility: facility, level_map: level_map, max_size: max_size)
         end
       end
     end

data/lib/semantic_logger/appender/tcp.rb

@@ -1,10 +1,10 @@
 begin
-  require 'net/tcp_client'
+  require "net/tcp_client"
 rescue LoadError
-  raise LoadError.new('Gem net_tcp_client is required for logging over TCP. Please add the gem "net_tcp_client" to your Gemfile.')
+  raise LoadError, 'Gem net_tcp_client is required for logging over TCP. Please add the gem "net_tcp_client" to your Gemfile.'
 end
 
-raise 'Net::TCPClient v2.0 or greater is required to log over TCP' unless Net::TCPClient::VERSION.to_f >= 2.0
+raise "Net::TCPClient v2.0 or greater is required to log over TCP" unless Net::TCPClient::VERSION.to_f >= 2.0
 
 module SemanticLogger
   module Appender
@@ -189,7 +189,7 @@ module SemanticLogger
 
         # Use the internal logger so that errors with remote logging are only written locally.
         Net::TCPClient.logger      = logger
-        Net::TCPClient.logger.name = 'Net::TCPClient'
+        Net::TCPClient.logger.name = "Net::TCPClient"
 
         super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, &block)
         reopen
@@ -198,7 +198,7 @@ module SemanticLogger
       # After forking an active process call #reopen to re-open the handles to resources.
       def reopen
         close
-        @tcp_client = Net::TCPClient.new(@tcp_client_args)
+        @tcp_client = Net::TCPClient.new(**@tcp_client_args)
       end
 
       # Write the log using the specified protocol and server.

data/lib/semantic_logger/appender/udp.rb

@@ -1,4 +1,4 @@
-require 'socket'
+require "socket"
 module SemanticLogger
   module Appender
     # UDP log appender.
@@ -74,7 +74,7 @@ module SemanticLogger
       def reopen
         close
         @socket    = UDPSocket.new
-        host, port = server.split(':')
+        host, port = server.split(":")
         @socket.connect(host, port.to_i)
       end
 

data/lib/semantic_logger/appender/wrapper.rb

@@ -32,7 +32,7 @@ module SemanticLogger
       #    require 'logger'
       #    require 'semantic_logger'
       #
-      #    ruby_logger = Logger.new(STDOUT)
+      #    ruby_logger = Logger.new($stdout)
       #    SemanticLogger.add_appender(logger: ruby_logger)
       #
       #    logger =  SemanticLogger['test']
@@ -45,7 +45,8 @@ module SemanticLogger
         # Check if the custom appender responds to all the log levels. For example Ruby ::Logger
         does_not_implement = LEVELS[1..-1].find { |i| !@logger.respond_to?(i) }
         if does_not_implement
-          raise(ArgumentError, "Supplied logger does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}")
+          raise(ArgumentError,
+                "Supplied logger does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}")
         end
 
         super(**args, &block)

data/lib/semantic_logger/appender.rb

@@ -1,35 +1,36 @@
 module SemanticLogger
   module Appender
     # @formatter:off
-    autoload :Async,             'semantic_logger/appender/async'
-    autoload :AsyncBatch,        'semantic_logger/appender/async_batch'
-    autoload :Bugsnag,           'semantic_logger/appender/bugsnag'
-    autoload :Elasticsearch,     'semantic_logger/appender/elasticsearch'
-    autoload :ElasticsearchHttp, 'semantic_logger/appender/elasticsearch_http'
-    autoload :File,              'semantic_logger/appender/file'
-    autoload :Graylog,           'semantic_logger/appender/graylog'
-    autoload :Honeybadger,       'semantic_logger/appender/honeybadger'
-    autoload :Kafka,             'semantic_logger/appender/kafka'
-    autoload :Sentry,            'semantic_logger/appender/sentry'
-    autoload :Http,              'semantic_logger/appender/http'
-    autoload :MongoDB,           'semantic_logger/appender/mongodb'
-    autoload :NewRelic,          'semantic_logger/appender/new_relic'
-    autoload :Rabbitmq,          'semantic_logger/appender/rabbitmq'
-    autoload :Splunk,            'semantic_logger/appender/splunk'
-    autoload :SplunkHttp,        'semantic_logger/appender/splunk_http'
-    autoload :Syslog,            'semantic_logger/appender/syslog'
-    autoload :Tcp,               'semantic_logger/appender/tcp'
-    autoload :Udp,               'semantic_logger/appender/udp'
-    autoload :Wrapper,           'semantic_logger/appender/wrapper'
+    autoload :Async,             "semantic_logger/appender/async"
+    autoload :AsyncBatch,        "semantic_logger/appender/async_batch"
+    autoload :Bugsnag,           "semantic_logger/appender/bugsnag"
+    autoload :Elasticsearch,     "semantic_logger/appender/elasticsearch"
+    autoload :ElasticsearchHttp, "semantic_logger/appender/elasticsearch_http"
+    autoload :File,              "semantic_logger/appender/file"
+    autoload :Graylog,           "semantic_logger/appender/graylog"
+    autoload :Honeybadger,       "semantic_logger/appender/honeybadger"
+    autoload :IO,                "semantic_logger/appender/io"
+    autoload :Kafka,             "semantic_logger/appender/kafka"
+    autoload :Sentry,            "semantic_logger/appender/sentry"
+    autoload :Http,              "semantic_logger/appender/http"
+    autoload :MongoDB,           "semantic_logger/appender/mongodb"
+    autoload :NewRelic,          "semantic_logger/appender/new_relic"
+    autoload :Rabbitmq,          "semantic_logger/appender/rabbitmq"
+    autoload :Splunk,            "semantic_logger/appender/splunk"
+    autoload :SplunkHttp,        "semantic_logger/appender/splunk_http"
+    autoload :Syslog,            "semantic_logger/appender/syslog"
+    autoload :Tcp,               "semantic_logger/appender/tcp"
+    autoload :Udp,               "semantic_logger/appender/udp"
+    autoload :Wrapper,           "semantic_logger/appender/wrapper"
+    autoload :SentryRuby,        "semantic_logger/appender/sentry_ruby"
     # @formatter:on
 
     # Returns [SemanticLogger::Subscriber] appender for the supplied options
     def self.factory(async: false, batch: nil,
-      max_queue_size: 10_000, lag_check_interval: 1_000, lag_threshold_s: 30,
-      batch_size: 300, batch_seconds: 5,
-      **args,
-      &block
-    )
+                     max_queue_size: 10_000, lag_check_interval: 1_000, lag_threshold_s: 30,
+                     batch_size: 300, batch_seconds: 5,
+                     **args,
+                     &block)
       appender = build(**args, &block)
 
       # If appender implements #batch, then it should use the batch proxy by default.
@@ -37,11 +38,11 @@ module SemanticLogger
 
       if batch == true
         Appender::AsyncBatch.new(
-          appender:           appender,
-          max_queue_size:     max_queue_size,
-          lag_threshold_s:    lag_threshold_s,
-          batch_size:         batch_size,
-          batch_seconds:      batch_seconds
+          appender:        appender,
+          max_queue_size:  max_queue_size,
+          lag_threshold_s: lag_threshold_s,
+          batch_size:      batch_size,
+          batch_seconds:   batch_seconds
         )
       elsif async == true
         Appender::Async.new(
@@ -57,8 +58,10 @@ module SemanticLogger
 
     # Returns [Subscriber] instance from the supplied options.
     def self.build(io: nil, file_name: nil, appender: nil, metric: nil, logger: nil, **args, &block)
-      if io || file_name
-        SemanticLogger::Appender::File.new(io: io, file_name: file_name, **args, &block)
+      if file_name
+        SemanticLogger::Appender::File.new(file_name, **args, &block)
+      elsif io
+        SemanticLogger::Appender::IO.new(io, **args, &block)
       elsif logger
         SemanticLogger::Appender::Wrapper.new(logger: logger, **args, &block)
       elsif appender
@@ -67,18 +70,21 @@ module SemanticLogger
         elsif appender.is_a?(Subscriber)
           appender
         else
-          raise(ArgumentError, "Parameter :appender must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
+          raise(ArgumentError,
+                "Parameter :appender must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
         end
       elsif metric
         if metric.is_a?(Symbol)
-          SemanticLogger::Utils.constantize_symbol(metric, 'SemanticLogger::Metric').new(**args)
+          SemanticLogger::Utils.constantize_symbol(metric, "SemanticLogger::Metric").new(**args)
         elsif metric.is_a?(Subscriber)
           metric
         else
-          raise(ArgumentError, "Parameter :metric must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
+          raise(ArgumentError,
+                "Parameter :metric must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
         end
       else
-        raise(ArgumentError, 'To create an appender it must supply one of the following: :io, :file_name, :appender, :metric, or :logger')
+        raise(ArgumentError,
+              "To create an appender it must supply one of the following: :io, :file_name, :appender, :metric, or :logger")
       end
     end