gelf_redux 3.1.1

data/lib/gelf/notifier.rb

@@ -0,0 +1,280 @@
+require 'gelf/transport/udp'
+require 'gelf/transport/tcp'
+require 'gelf/transport/tcp_tls'
+
+# replace JSON and #to_json with Yajl if available
+begin
+  require 'yajl/json_gem'
+rescue LoadError
+end
+
+module GELF
+  # Graylog2 notifier.
+  class Notifier
+    # Maximum number of GELF chunks as per GELF spec
+    MAX_CHUNKS = 128
+    MAX_CHUNK_SIZE_WAN = 1420
+    MAX_CHUNK_SIZE_LAN = 8154
+
+    attr_accessor :enabled, :collect_file_and_line, :rescue_network_errors
+    attr_reader :max_chunk_size, :level, :default_options, :level_mapping
+
+    # +host+ and +port+ are host/ip and port of graylog2-server.
+    # +max_size+ is passed to max_chunk_size=.
+    # +default_options+ is used in notify!
+    def initialize(host = 'localhost', port = 12201, max_size = 'WAN', default_options = {})
+      @enabled = true
+      @collect_file_and_line = true
+      @random = Random.new
+
+      self.level = GELF::DEBUG
+      self.max_chunk_size = max_size
+      self.rescue_network_errors = false
+
+      self.default_options = default_options.dup
+      self.default_options['version'] = SPEC_VERSION
+      self.default_options['host'] ||= Socket.gethostname
+      self.default_options['level'] ||= GELF::UNKNOWN
+      self.default_options['facility'] ||= 'gelf-rb'
+      self.default_options['protocol'] ||= GELF::Protocol::UDP
+
+      self.level_mapping = :logger
+      @sender = create_sender(host, port)
+    end
+
+    # Get a list of receivers.
+    #    notifier.addresses  # => [['localhost', 12201], ['localhost', 12202]]
+    def addresses
+      @sender.addresses
+    end
+
+    # Set a list of receivers.
+    #    notifier.addresses = [['localhost', 12201], ['localhost', 12202]]
+    def addresses=(addrs)
+      @sender.addresses = addrs
+    end
+
+    # +size+ may be a number of bytes, 'WAN' (1420 bytes) or 'LAN' (8154).
+    # Default (safe) value is 'WAN'.
+    def max_chunk_size=(size)
+      case size.to_s.downcase
+        when 'wan'
+          @max_chunk_size = MAX_CHUNK_SIZE_WAN
+        when 'lan'
+          @max_chunk_size = MAX_CHUNK_SIZE_LAN
+        else
+          @max_chunk_size = size.to_int
+      end
+    end
+
+    def level=(new_level)
+      @level = if new_level.is_a?(Integer)
+                 new_level
+               else
+                 GELF.const_get(new_level.to_s.upcase)
+               end
+    end
+
+    def default_options=(options)
+      @default_options = self.class.stringify_keys(options)
+    end
+
+    # +mapping+ may be a hash, 'logger' (GELF::LOGGER_MAPPING) or 'direct' (GELF::DIRECT_MAPPING).
+    # Default (compatible) value is 'logger'.
+    def level_mapping=(mapping)
+      case mapping.to_s.downcase
+        when 'logger'
+          @level_mapping = GELF::LOGGER_MAPPING
+        when 'direct'
+          @level_mapping = GELF::DIRECT_MAPPING
+        else
+          @level_mapping = mapping
+      end
+    end
+
+    def disable
+      @enabled = false
+    end
+
+    def enable
+      @enabled = true
+    end
+
+    # Closes sender
+    def close
+      @sender.close
+    end
+
+    # Same as notify!, but rescues all exceptions (including +ArgumentError+)
+    # and sends them instead.
+    def notify(*args)
+      notify_with_level(nil, *args)
+    end
+
+    # Sends message to Graylog2 server.
+    # +args+ can be:
+    # - hash-like object (any object which responds to +to_hash+, including +Hash+ instance):
+    #    notify!(:short_message => 'All your rebase are belong to us', :user => 'AlekSi')
+    # - exception with optional hash-like object:
+    #    notify!(SecurityError.new('ALARM!'), :trespasser => 'AlekSi')
+    # - string-like object (anything which responds to +to_s+) with optional hash-like object:
+    #    notify!('Plain olde text message', :scribe => 'AlekSi')
+    # Resulted fields are merged with +default_options+, the latter will never overwrite the former.
+    # This method will raise +ArgumentError+ if arguments are wrong. Consider using notify instead.
+    def notify!(*args)
+      notify_with_level!(nil, *args)
+    end
+
+    GELF::Levels.constants.each do |const|
+      define_method(const.downcase) do |*args|
+        level = GELF.const_get(const)
+        notify_with_level(level, *args)
+      end
+    end
+
+  private
+
+    def create_sender(host, port)
+      addresses = [[host, port]]
+      if default_options['protocol'] == GELF::Protocol::TCP
+        if default_options.key?('tls')
+          tls_options = default_options.delete('tls')
+          GELF::Transport::TCPTLS.new(addresses, tls_options)
+        else
+          GELF::Transport::TCP.new(addresses)
+        end
+      else
+        GELF::Transport::UDP.new(addresses)
+      end
+    end
+
+    def notify_with_level(message_level, *args)
+      notify_with_level!(message_level, *args)
+    rescue SocketError, SystemCallError
+      raise unless rescue_network_errors
+    rescue Exception => exception
+      notify_with_level!(GELF::UNKNOWN, exception)
+    end
+
+    def notify_with_level!(message_level, *args)
+      return unless @enabled
+      hash = extract_hash(*args)
+      hash['level'] = message_level unless message_level.nil?
+      if hash['level'] >= level
+        if default_options['protocol'] == GELF::Protocol::TCP
+          validate_hash(hash)
+          @sender.send(hash.to_json + "\0")
+        else
+          @sender.send_datagrams(datagrams_from_hash(hash))
+        end
+      end
+    end
+
+    def extract_hash(object = nil, args = {})
+      primary_data = if object.respond_to?(:to_hash)
+                       object.to_hash
+                     elsif object.is_a?(Exception)
+                       args['level'] ||= GELF::ERROR
+                       self.class.extract_hash_from_exception(object)
+                     else
+                       args['level'] ||= GELF::INFO
+                       { 'short_message' => object.to_s }
+                     end
+
+      hash = default_options.merge(self.class.stringify_keys(args.merge(primary_data)))
+      convert_hoptoad_keys_to_graylog2(hash)
+      set_file_and_line(hash) if @collect_file_and_line
+      set_timestamp(hash)
+      check_presence_of_mandatory_attributes(hash)
+      hash
+    end
+
+    def self.extract_hash_from_exception(exception)
+      bt = exception.backtrace || ["Backtrace is not available."]
+      {
+        'short_message' => "#{exception.class}: #{exception.message}",
+        'full_message' => "Backtrace:\n" + bt.join("\n")
+      }
+    end
+
+    # Converts Hoptoad-specific keys in +@hash+ to Graylog2-specific.
+    def convert_hoptoad_keys_to_graylog2(hash)
+      if hash['short_message'].to_s.empty?
+        if hash.has_key?('error_class') && hash.has_key?('error_message')
+          hash['short_message'] = hash.delete('error_class') + ': ' + hash.delete('error_message')
+        end
+      end
+    end
+
+    CALLER_REGEXP = /^(.*):(\d+).*/
+    LIB_GELF_PATTERN = File.join('lib', 'gelf')
+
+    def set_file_and_line(hash)
+      stack = caller
+      frame = stack.find { |f| !f.include?(LIB_GELF_PATTERN) }
+      match = CALLER_REGEXP.match(frame)
+      hash['file'] = match[1]
+      hash['line'] = match[2].to_i
+    end
+
+    def set_timestamp(hash)
+      hash['timestamp'] = Time.now.utc.to_f if hash['timestamp'].nil?
+    end
+
+    def check_presence_of_mandatory_attributes(hash)
+      %w(version short_message host).each do |attribute|
+        if hash[attribute].to_s.empty?
+          raise ArgumentError.new("#{attribute} is missing. Options version, short_message and host must be set.")
+        end
+      end
+    end
+
+    def datagrams_from_hash(hash)
+      data = serialize_hash(hash)
+      datagrams = []
+
+      # Maximum total size is 8192 byte for UDP datagram. Split to chunks if bigger. (GELF v1.0 supports chunking)
+      if data.count > @max_chunk_size
+        id = @random.bytes(8)
+        msg_id = Digest::MD5.digest("#{Time.now.to_f}-#{id}")[0, 8]
+        num, count = 0, (data.count.to_f / @max_chunk_size).ceil
+        if count > MAX_CHUNKS
+          raise ArgumentError, "Data too big (#{data.count} bytes), would create more than #{MAX_CHUNKS} chunks!"
+        end
+        data.each_slice(@max_chunk_size) do |slice|
+          datagrams << "\x1e\x0f" + msg_id + [num, count, *slice].pack('C*')
+          num += 1
+        end
+      else
+        datagrams << data.to_a.pack('C*')
+      end
+
+      datagrams
+    end
+
+    def validate_hash(hash)
+      raise ArgumentError.new("Hash is empty.") if hash.nil? || hash.empty?
+      hash['level'] = @level_mapping[hash['level']]
+    end
+
+    def serialize_hash(hash)
+      validate_hash(hash)
+
+      Zlib::Deflate.deflate(hash.to_json).bytes
+    end
+
+    def self.stringify_keys(data)
+      return data unless data.is_a? Hash
+
+      data.each_with_object({}) do |(key, value), obj|
+        key_s = key.to_s
+
+        if (key != key_s) && data.key?(key_s)
+          raise ArgumentError, "Both #{key.inspect} and #{key_s} are present."
+        end
+
+        obj[key_s] = value
+      end
+    end
+  end
+end

data/lib/gelf/severity.rb

@@ -0,0 +1,50 @@
+module GELF
+  # There are two things you should know about log levels/severity:
+  #  - syslog defines levels from 0 (Emergency) to 7 (Debug).
+  #    0 (Emergency) and 1 (Alert) levels are reserved for OS kernel.
+  #  - Ruby default Logger defines levels from 0 (DEBUG) to 4 (FATAL) and 5 (UNKNOWN).
+  #    Note that order is inverted.
+  # For compatibility we define our constants as Ruby Logger, and convert values before
+  # generating GELF message, using defined mapping.
+
+  module Levels
+    DEBUG   = 0
+    INFO    = 1
+    WARN    = 2
+    ERROR   = 3
+    FATAL   = 4
+    UNKNOWN = 5
+    # Additional native syslog severities. These will work in direct mapping mode
+    # only, for compatibility with syslog sources unrelated to Logger.
+    EMERGENCY     = 10
+    ALERT         = 11
+    CRITICAL      = 12
+    WARNING       = 14
+    NOTICE        = 15
+    INFORMATIONAL = 16
+  end
+
+  include Levels
+
+  # Maps Ruby Logger levels to syslog levels as SyslogLogger and syslogger gems. This one is default.
+  LOGGER_MAPPING = {DEBUG   => 7, # Debug
+                    INFO    => 6, # Informational
+                    WARN    => 5, # Notice
+                    ERROR   => 4, # Warning
+                    FATAL   => 3, # Error
+                    UNKNOWN => 1} # Alert – shouldn't be used
+
+  # Maps Syslog or Ruby Logger levels directly to standard syslog numerical severities.
+  DIRECT_MAPPING = {DEBUG         => 7, # Debug
+                    INFORMATIONAL => 6, # Informational (syslog source)
+                    INFO          => 6, # Informational (Logger source)
+                    NOTICE        => 5, # Notice
+                    WARNING       => 4, # Warning (syslog source)
+                    WARN          => 4, # Warning (Logger source)
+                    ERROR         => 3, # Error
+                    CRITICAL      => 2, # Critical (syslog source)
+                    FATAL         => 2, # Critical (Logger source)
+                    ALERT         => 1, # Alert (syslog source)
+                    UNKNOWN       => 1, # Alert - shouldn't be used (Logger source)
+                    EMERGENCY     => 0} # Emergency (syslog source)
+end

data/lib/gelf/transport/tcp.rb

@@ -0,0 +1,79 @@
+module GELF
+  module Transport
+    class TCP
+      attr_reader :addresses
+
+      # `addresses` Array of [host, port] pairs
+      def initialize(addresses)
+        @sockets = []
+        self.addresses = addresses
+      end
+
+      def addresses=(addresses)
+        @addresses = addresses.dup.freeze.tap do |addrs|
+          @sockets.each(&:close)
+          @sockets = addrs.map { |peer| connect(*peer) }
+        end
+      end
+
+      def send(message)
+        return if @addresses.empty?
+        loop do
+          connected = @sockets.reject(&:closed?)
+          reconnect_all if connected.empty?
+          break if write_any(connected, message)
+        end
+      end
+
+      private
+
+      def connect(host, port)
+        socket_class.new(host, port)
+      end
+
+      def reconnect_all
+        @sockets = @sockets.each_with_index.map do |old_socket, index|
+          old_socket.closed? ? connect(*@addresses[index]) : old_socket
+        end
+      end
+
+      def socket_class
+        if defined?(Celluloid::IO::TCPSocket)
+          Celluloid::IO::TCPSocket
+        else
+          ::TCPSocket
+        end
+      end
+
+      def write_any(sockets, message)
+        sockets.shuffle.each do |socket|
+          return true if write_socket(socket, message)
+        end
+        false
+      end
+
+      def write_socket(socket, message)
+        unsafe_write_socket(socket, message)
+      rescue IOError, SystemCallError
+        socket.close unless socket.closed?
+        false
+      end
+
+      def unsafe_write_socket(socket, message)
+        r,w = IO.select([socket], [socket])
+        # Read everything first
+        while r.any? do
+          # don't expect any reads, but a readable socket might
+          # mean the remote end closed, so read it and throw it away.
+          # we'll get an EOFError if it happens.
+          socket.sysread(16384)
+          r = IO.select([socket])
+        end
+
+        # Now send the payload
+        return false unless w.any?
+        return socket.syswrite(message) > 0
+      end
+    end
+  end
+end

data/lib/gelf/transport/tcp_tls.rb

@@ -0,0 +1,129 @@
+require 'openssl'
+
+module GELF
+  module Transport
+    # Provides encryption capabilities for TCP connections
+    class TCPTLS < TCP
+      # Supported tls_options:
+      #   'no_default_ca' [Boolean] prevents OpenSSL from using the systems CA store.
+      #   'version' [Symbol] any of :TLSv1, :TLSv1_1, :TLSv1_2 (default)
+      #   'ca' [String] the path to a custom CA store
+      #   'cert' [String, IO] the client certificate file
+      #   'key' [String, IO] the key for the client certificate
+      #   'all_ciphers' [Boolean] allows any ciphers to be used, may be insecure
+      #   'rescue_ssl_errors' [Boolean] similar to rescue_network_errors in notifier.rb, allows SSL exceptions to be raised
+      #   'no_verify' [Boolean] disable peer verification
+
+      attr_accessor :rescue_ssl_errors
+
+      def initialize(addresses, tls_options={})
+        @tls_options = tls_options
+        @rescue_ssl_errors = @tls_options['rescue_ssl_errors']
+        @rescue_ssl_errors if @rescue_ssl_errors.nil?
+        super(addresses)
+      end
+
+      protected
+
+      def write_socket(socket, message)
+        super(socket, message)
+      rescue OpenSSL::SSL::SSLError
+        socket.close unless socket.closed?
+        raise unless rescue_ssl_errors
+        false
+      end
+
+      def connect(host, port)
+        plain_socket = super(host, port)
+        start_tls(plain_socket)
+      rescue OpenSSL::SSL::SSLError
+        plain_socket.close unless plain_socket.closed?
+        raise unless rescue_ssl_errors
+        nil
+      end
+
+      # Initiates TLS communication on the socket
+      def start_tls(plain_socket)
+        ssl_socket_class.new(plain_socket, ssl_context).tap do |ssl_socket|
+          ssl_socket.sync_close = true
+          ssl_socket.connect
+        end
+      end
+
+      def ssl_socket_class
+        if defined?(Celluloid::IO::SSLSocket)
+          Celluloid::IO::SSLSocket
+        else
+          OpenSSL::SSL::SSLSocket
+        end
+      end
+
+      def ssl_context
+        @ssl_context ||= OpenSSL::SSL::SSLContext.new.tap do |ctx|
+          ctx.cert_store = ssl_cert_store
+          ctx.ssl_version = tls_version
+          ctx.verify_mode = verify_mode
+          set_certificate_and_key(ctx)
+          restrict_ciphers(ctx) unless @tls_options['all_ciphers']
+        end
+      end
+
+      def set_certificate_and_key(context)
+        return unless @tls_options['cert'] && @tls_options['key']
+        context.cert = OpenSSL::X509::Certificate.new(resource(@tls_options['cert']))
+        context.key = OpenSSL::PKey::RSA.new(resource(@tls_options['key']))
+      end
+
+      # checks whether {resource} is a filename and tries to read it
+      # otherwise treats it as if it already contains certificate/key data
+      def resource(data)
+        if data.is_a?(String) && File.exist?(data)
+          File.read(data)
+        else
+          data
+        end
+      end
+
+      # Ciphers have to come from the CipherString class, specifically the _TXT_ constants here - https://github.com/jruby/jruby-openssl/blob/master/src/main/java/org/jruby/ext/openssl/CipherStrings.java#L47-L178
+      def restrict_ciphers(ctx)
+        # This CipherString is will allow a variety of 'currently' cryptographically secure ciphers, 
+        # while also retaining a broad level of compatibility
+        ctx.ciphers = "TLSv1_2:TLSv1_1:TLSv1:!aNULL:!eNULL:!LOW:!3DES:!MD5:!EXP:!PSK:!DSS:!RC4:!SEED:!ECDSA:!ADH:!IDEA:!3DES"
+      end
+
+      def verify_mode
+        @tls_options['no_verify'] ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+      end
+
+      # SSL v2&3 are insecure, forces at least TLS v1.0 and defaults to v1.2
+      def tls_version
+        if @tls_options.key?('version') &&
+            OpenSSL::SSL::SSLContext::METHODS.include?(@tls_options['version']) &&
+            @tls_options['version'] =~ /\ATLSv/
+          @tls_options['version']
+        else
+          :TLSv1_2
+        end
+      end
+
+      def ssl_cert_store
+        OpenSSL::X509::Store.new.tap do |store|
+          unless @tls_options['no_default_ca']
+            store.set_default_paths
+          end
+
+          if @tls_options.key?('ca')
+            ca = @tls_options['ca']
+            if File.directory?(ca)
+              store.add_path(@tls_options['ca'])
+            elsif File.file?(ca)
+              store.add_file(ca)
+            else
+              $stderr.puts "No directory or file: #{ca}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gelf/transport/udp.rb

@@ -0,0 +1,41 @@
+module GELF
+  module Transport
+    class UDP
+      attr_accessor :addresses
+
+      def initialize(addresses)
+        @addresses = addresses
+      end
+
+      def send_datagrams(datagrams)
+        socket = get_socket
+        idx = get_address_index
+
+        host, port = @addresses[idx]
+        set_address_index((idx + 1) % @addresses.length)
+        datagrams.each do |datagram|
+          socket.send(datagram, 0, host, port)
+        end
+      end
+
+      def close
+        socket = get_socket
+        socket.close if socket
+      end
+
+      private
+
+      def get_socket
+        Thread.current[:gelf_udp_socket] ||= UDPSocket.open
+      end
+
+      def get_address_index
+        Thread.current[:gelf_udp_address_idx] ||= 0
+      end
+
+      def set_address_index(value)
+        Thread.current[:gelf_udp_address_idx] = value
+      end
+    end
+  end
+end

data/lib/gelf.rb

@@ -0,0 +1,16 @@
+require 'json'
+require 'socket'
+require 'zlib'
+require 'digest/md5'
+
+module GELF
+  SPEC_VERSION = '1.0'
+  module Protocol
+    UDP = 0
+    TCP = 1
+  end
+end
+
+require 'gelf/severity'
+require 'gelf/notifier'
+require 'gelf/logger'

data/test/helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha/setup'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'gelf'
+
+class Test::Unit::TestCase
+end