analogger 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7e212d5f72a1ed3e46b15cc9967b0b4558b22808215e3a7b3c213fb7ad8aa83
-  data.tar.gz: 41937ddf5b49f6eb741ded33748ea90ecb82139846fc4b002f90495b99b19cb6
+  metadata.gz: f3ec71320cfc00f16d6073e54ce2f9b3134f511b046365c99738c756a38ee00d
+  data.tar.gz: '086bc16bd8cfb9c971b6c73aa1ccfa6342474cc7a7e3d79d795b28a55dfc8746'
 SHA512:
-  metadata.gz: 5edca0ff4568f72164b08e9b2ff87415f56edeadbb308308ef9cc882902e6f1c03ed2a13fd0f0059b69d6f84d0d35a52032af6858c3c6ff4df3f731b8e632555
-  data.tar.gz: 1339888e798a75186b11d8aa27db42ef6ab97b133dc9b4e2c24dcbc486e2f707fe3a762197d6f412654261ce0bdc7b365ef60849fc8463fb2f590054115887bc
+  metadata.gz: 33afab0699d63cd5a0f78d70b4533900001a112a76ea9d5f585aa0a920127abffc2960436d4b2b3609a58044d3cbfe87081196634172c5a80fd3c9a74f531ee7
+  data.tar.gz: 368dd4f344260e13d885d6c6cc9b8d2b97561ae0e407b440c438cc1113d6dbc5d1c61306065711061cc0a035612a761b07d60d5e1b9d25f05fc1b7db30aa2f69

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    analogger (0.9.0)
-      eventmachine (~> 1.2)
+    analogger (0.9.2)
+      eventmachine (~> 1.2.5)
 
 GEM
   remote: https://rubygems.org/

data/README

@@ -1,19 +1,65 @@
-Swiftcore Analogger 0.5
+# Analogger
 
-Homepage::  http://analogger.swiftcore.org
-Copyright:: (C) 2007 by Kirk Haines. All Rights Reserved.
-Email:: wyhaines@gmail.com
-License:: Ruby's License
+## Overview
 
-The Swiftcore Analogger implements a fast asynchronous logging system
-for Ruby programs as well as client library for sending logging messages
-to the Analogger process.
+Analogger is a fast asynchronous logging service and client library. It is
+implemented in Ruby, and currently uses EventMachine in the server, though
+there is a plan on the roadmap to enable it to run with a pure Ruby event
+reactor.
 
-Analogger will accept logs from multiple sources and can have multiple
-logging destinations.  Currently, logging to a file, to STDOUT, or to
-STDERR is supported.  A future revision may support logging to a
-database destination, as well.
+Analogger was originally written over a decade ago, in response to a need to
+maintain a central logging server to accumulate logs from numerous web
+applications to a single location. It takes very little time to send a logging
+message, making it a very low impact logger for performance sensitive
+applications. It has been continuously used in production since then, albeit
+in a version not released publicly.
 
-Analogger depends on EventMachine (http://rubyforge.org/projects/eventmachine)
-to provide the framework for the network communications, though EM is
-not used for the client library.
+## Usage
+
+Analogger is configured through a YAML formatted file:
+
+```yaml
+host: mycompany-logger-1-nyc1.private
+port: 6766
+default_log: /var/log/analogger_default
+daemonize: true
+syncinterval: 5
+logs:
+- service:
+  - default
+  logfile: /var/log/analogger/default
+  cull: true
+- service:
+  - project-development
+  logfile: /var/log/analogger/project-development.log
+- service:
+  - project-production
+  logfile: /var/log/analogger/project-production.log
+  cull: true
+```
+
+### Configuration Variables
+
+* port
+
+  The port to listen for connections on. 6766 is the default.
+
+* host
+
+  The hostname or IP to bind to when listening for connections.
+
+* default_log: /var/log/analogger_default
+
+  This is the file to send logs to which don't appear to match any named service in the configuration.
+
+* daemonize
+
+  Whether or not to detach an analogger process as a daemon process. You normally want this to be true.
+
+* syncinterval
+
+  Analogger will run a thread every X seconds to ensure that any currently buffered log contents are synchronized to disk. Analogger tries to write any buffered logs before it exits if it receives a signal which would cause the process to die. However, in the event that this is not possible, only the logs received since the last sync interval would be at risk.
+
+* logs
+
+  This is a list of defined logging services. Each consists of a service label, a logging destination (the path to the log file for that service), and optionally a `cull` attribute which, if true, causes analogger to deduplicate logs, eliminating consecutive repeats of the same message and instead emitting a summary of how many records like the one above the summary were culled.

data/analogger.gemspec

@@ -38,6 +38,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 11.0"
   spec.add_development_dependency "minitest", "~> 5"
-  spec.add_runtime_dependency "eventmachine", "~> 1.2"
+  spec.add_runtime_dependency "eventmachine", "~> 1.2.5"
 end
 

data/bin/analogger

@@ -1,4 +1,4 @@
-#!ruby
+#!/usr/bin/env ruby
 
 require 'yaml'
 require 'optparse'
@@ -47,39 +47,39 @@ module Swiftcore
       #   cull: true
       #
       OptionParser.new do |opts|
-        opts.banner = "Analogger v#{Swiftcore::Analogger::VERSION}\nUsage: analogger.rb [options]"
-        opts.separator ''
-        opts.on('-c', '--config CONFFILE', "The configuration file to read.") do |conf|
+        opts.banner = -"Analogger v#{Swiftcore::Analogger::VERSION}\nUsage: analogger.rb [options]"
+        opts.separator -""
+        opts.on(-"-c", -"--config CONFFILE", "The configuration file to read.") do |conf|
           config = YAML.load(File.read(conf))
         end
-        opts.on('-p', '--port [PORT]', Integer, "The port to receive connections on.") do |port|
-          config[Swiftcore::Analogger::Cport] = port
+        opts.on(-"-p", -"--port [PORT]", Integer, "The port to receive connections on.") do |port|
+          config[-"port"] = port
         end
-        opts.on('-h', '--host [HOST]', String, "The host to bind the connection to.") do |host|
-          config[Swiftcore::Analogger::Chost] = host
+        opts.on(-"-h", -"--host [HOST]", String, "The host to bind the connection to.") do |host|
+          config[-"host"] = host
         end
-#				opts.on('-r','--controlkey [KEY]',String,"The secret key that authenticates a control session.") do |secret|
-#					config[Swiftcore::Analogger::Csecret] = secret
-#				end
-        opts.on('-k', '--key [KEY]', String, "The secret key that authenticates a valid client session.") do |secret|
-          config[Swiftcore::Analogger::Ckey] = secret
+	opts.on(-"-r",-"--controlkey [KEY]",String,-"The secret key that authenticates a control session.") do |secret|
+          config[-"secret"] = secret
+	end
+        opts.on(-"-k", -"--key [KEY]", String, -"The secret key that authenticates a valid client session.") do |secret|
+          config[-"key"] = secret
         end
-        opts.on('-i', '--interval [INTERVAL]', Integer, "The interval between queue writes.  Defaults to 1 second.") do |interval|
-          config[Swiftcore::Analogger::Cinterval] = interval
+        opts.on(-"-i", -"--interval [INTERVAL]", Integer, -"The interval between queue writes.  Defaults to 1 second.") do |interval|
+          config[-"interval"] = interval
         end
-        opts.on('-s', '--syncinterval [INTERVAL]', Integer, "The interval between queue syncs.  Defaults to 60 seconds.") do |interval|
-          config[Swiftcore::Analogger::Csyncinterval] = interval
+        opts.on(-"-s", -"--syncinterval [INTERVAL]", Integer, -"The interval between queue syncs.  Defaults to 60 seconds.") do |interval|
+          config[-"syncinterval"] = interval
         end
-        opts.on('-d', '--default [PATH]', String, "The default log destination.  Defaults to stdout.") do |default|
-          config[Swiftcore::Analogger::Cdefault_log] = default
+        opts.on(-"-d", -"--default [PATH]", String, -"The default log destination.  Defaults to stdout.") do |default|
+          config[-"default_log"] = default
         end
-        opts.on('-x', '--daemonize', "Tell the Analogger to daemonize itself.") do
-          config[Swiftcore::Analogger::Cdaemonize] = true
+        opts.on(-"-x", -"--daemonize", -"Tell the Analogger to daemonize itself.") do
+          config[-"daemonize"] = true
         end
-        opts.on('-w', '--writepid [FILENAME]', "The filename to write a PID file to.") do |pidfile|
-          config[Swiftcore::Analogger::Cpidfile] = pidfile || 'analogger.pid'
+        opts.on(-"-w", -"--writepid [FILENAME]", -"The filename to write a PID file to.") do |pidfile|
+          config[-"pidfile"] = pidfile || 'analogger.pid'
         end
-        opts.on('-v', '--version', "Show the current version of Analogger.") do
+        opts.on(-"-v", -"--version", -"Show the current version of Analogger.") do
           puts "Analogger v#{Swiftcore::Analogger::VERSION}"
           exit
         end
@@ -95,6 +95,4 @@ module Swiftcore
   end
 end
 
-loop do
-  catch(:hup) {Swiftcore::AnaloggerExec.run}
-end
+Swiftcore::AnaloggerExec.run

data/lib/swiftcore/Analogger.rb

@@ -6,25 +6,9 @@ require 'swiftcore/Analogger/AnaloggerProtocol'
 
 module Swiftcore
   class Analogger
-    C_colon = ':'.freeze
-    C_bar = '|'.freeze
-    Ccull = 'cull'.freeze
-    Cdaemonize = 'daemonize'.freeze
-    Cdefault = 'default'.freeze
-    Cdefault_log = 'default_log'.freeze
-    Chost = 'host'.freeze
-    Cinterval = 'interval'.freeze
-    Ckey = 'key'.freeze
-    Clogfile = 'logfile'.freeze
-    Clogs = 'logs'.freeze
-    Cport = 'port'.freeze
-    Csecret = 'secret'.freeze
-    Cservice = 'service'.freeze
-    Clevels = 'levels'.freeze
-    Csyncinterval = 'syncinterval'.freeze
-    Cpidfile = 'pidfile'.freeze
-    DefaultSeverityLevels = ['debug','info','warn','error','fatal'].inject({}){|h,k|h[k]=true;h}
-    TimeFormat = '%Y/%m/%d %H:%M:%S'.freeze
+    EXEC_ARGUMENTS = [File.expand_path(Process.argv0), *ARGV]
+
+    DefaultSeverityLevels = [-"debug",-"info",-"warn",-"error",-"fatal"].inject({}){|h,k|h[k]=true;h}
 
     class NoPortProvided < Exception; def to_s; "The port to bind to was not provided."; end; end
     class BadPort < Exception
@@ -37,6 +21,7 @@ module Swiftcore
 
     EXIT_SIGNALS = %w[INT TERM]
     RELOAD_SIGNALS = %w[HUP]
+    RESTART_SIGNALS = %w[USR2]
 
     class << self
       def safe_trap(siglist, &operation)
@@ -45,8 +30,8 @@ module Swiftcore
 
       def start(config,protocol = AnaloggerProtocol)
         @config = config
-        daemonize if @config[Cdaemonize]
-        File.open(@config[Cpidfile],'w+') {|fh| fh.puts $$} if @config[Cpidfile]
+        daemonize if @config[-"daemonize"]
+        File.open(@config[-"pidfile"],-"w+") {|fh| fh.puts $$} if @config[-"pidfile"]
         @logs = Hash.new {|h,k| h[k] = new_log(k)}
         @queue = Hash.new {|h,k| h[k] = []}
         postprocess_config_load
@@ -57,8 +42,8 @@ module Swiftcore
         @wcount = 0
         @server = nil
         safe_trap(EXIT_SIGNALS) {handle_pending_and_exit}
-        safe_trap(RELOAD_SIGNALS) {cleanup;throw :hup}
-
+        safe_trap(RELOAD_SIGNALS) {cleanup_and_reopen}
+        safe_trap(RESTART_SIGNALS) {exec(*EXEC_ARGUMENTS)}
 
         #####
         # This is gross.  EM needs to change so that it defaults to the faster
@@ -80,17 +65,17 @@ module Swiftcore
             flush_queue
             cleanup
           end
-          @server = EventMachine.start_server @config[Chost], @config[Cport], protocol
+          @server = EventMachine.start_server @config[-"host"], @config[-"port"], protocol
           EventMachine.add_periodic_timer(1) {Analogger.update_now}
-          EventMachine.add_periodic_timer(@config[Cinterval]) {write_queue}
-          EventMachine.add_periodic_timer(@config[Csyncinterval]) {flush_queue}
+          EventMachine.add_periodic_timer(@config[-"interval"]) {write_queue}
+          EventMachine.add_periodic_timer(@config[-"syncinterval"]) {flush_queue}
         }
         exit
       end
 
       def daemonize
         if (child_pid = fork)
-          puts "PID #{child_pid}" unless @config[Cpidfile]
+          puts "PID #{child_pid}" unless @config[-"pidfile"]
           exit!
         end
         Process.setsid
@@ -101,8 +86,8 @@ module Swiftcore
         puts "Platform (#{RUBY_PLATFORM}) does not appear to support fork/setsid; skipping"
       end
 
-      def new_log(facility = Cdefault, levels = @config[Clevels] || DefaultSeverityLevels, log = @config[Cdefault_log], cull = true)
-        Log.new({Cservice => facility, Clevels => levels, Clogfile => log, Ccull => cull})
+      def new_log(facility = -"default", levels = @config[-"levels"] || DefaultSeverityLevels, log = @config[-"default_log"], cull = true)
+        Log.new({-"service" => facility, -"levels" => levels, -"logfile" => log, -"cull" => cull})
       end
 
       # Before exiting, try to get any logs that are still in memory handled and written to disk.
@@ -129,8 +114,15 @@ module Swiftcore
         end
       end
 
+      def cleanup_and_reopen
+        @logs.each do |service,l|
+          l.logfile.fsync if !l.logfile.closed? and l.logfile.fileno > 2
+          l.logfile.reopen(l.logfile.path, -"ab+") if l.logfile.fileno > 2
+        end
+      end
+
       def update_now
-        @now = Time.now.strftime(TimeFormat)
+        @now = Time.now.strftime(-"%Y/%m/%d %H:%M:%S")
       end
 
       def config
@@ -142,26 +134,26 @@ module Swiftcore
       end
 
       def populate_logs
-        @config[Clogs].each do |log|
-          next unless log[Cservice]
-          if Array === log[Cservice]
-            log[Cservice].each do |loglog|
-              @logs[loglog] = new_log(loglog,log[Clevels],logfile_destination(log[Clogfile]),log[Ccull])
+        @config[-"logs"].each do |log|
+          next unless log[-"service"]
+          if Array === log[-"service"]
+            log[-"service"].each do |loglog|
+              @logs[loglog] = new_log(loglog,log[-"levels"],logfile_destination(log[-"logfile"]),log[-"cull"])
             end
           else
-            @logs[log[Cservice]] = new_log(log[Cservice],log[Clevels],logfile_destination(log[Clogfile]),log[Ccull])
+            @logs[log[-"service"]] = new_log(log[-"service"],log[-"levels"],logfile_destination(log[-"logfile"]),log[-"cull"])
           end
         end
       end
 
       def postprocess_config_load
-        @config[Clogs] ||= []
-        if @config[Clevels]
-          @config[Clevels] = normalize_levels(@config[Clevels])
+        @config[-"logs"] ||= []
+        if @config[-"levels"]
+          @config[-"levels"] = normalize_levels(@config[-"levels"])
         end
 
-        @config[Clogs].each do |log|
-          log[Clevels] = normalize_levels(log[Clevels])
+        @config[-"logs"].each do |log|
+          log[-"levels"] = normalize_levels(log[-"levels"])
         end
       end
 
@@ -180,18 +172,18 @@ module Swiftcore
       end
 
       def check_config_settings
-        raise NoPortProvided unless @config[Cport]
-        raise BadPort.new(@config[Cport]) unless @config[Cport].to_i > 0
+        raise NoPortProvided unless @config[-"port"]
+        raise BadPort.new(@config[-"port"]) unless @config[-"port"].to_i > 0
       end
 
       def set_config_defaults
-        @config[Chost] ||= '127.0.0.1'
-        @config[Cinterval] ||= 1
-        @config[Csyncinterval] ||= 60
-        @config[Csyncinterval] = nil if @config[Csyncinterval] == 0
-        @config[Cdefault_log] = @config[Cdefault_log].nil? || @config[Cdefault_log] == '-' ? 'STDOUT' : @config[Cdefault_log]
-        @config[Cdefault_log] = logfile_destination(@config[Cdefault_log])
-        @logs['default'] = new_log
+        @config[-"host"] ||= -"127.0.0.1"
+        @config[-"interval"] ||= 1
+        @config[-"syncinterval"] ||= 60
+        @config[-"syncinterval"] = nil if @config[-"syncinterval"] == 0
+        @config[-"default_log"] = @config[-"default_log"].nil? || @config[-"default_log"] == -"-" ? -"STDOUT" : @config[-"default_log"]
+        @config[-"default_log"] = logfile_destination(@config[-"default_log"])
+        @logs[-"default"] = new_log
       end
 
       def logfile_destination(logfile)
@@ -199,7 +191,7 @@ module Swiftcore
         if logfile.is_a?(IO)
           return $stdout if logfile == $stdout
           return $stderr if logfile == $stderr
-          return logfile.reopen(logfile.path, 'ab+')
+          return logfile.reopen(logfile.path, -"ab+")
         end
 
         if logfile =~ /^STDOUT$/i
@@ -207,7 +199,7 @@ module Swiftcore
         elsif logfile =~ /^STDERR$/i
           $stderr
         else
-          File.open(logfile,'ab+')
+          File.open(logfile, -"ab+")
         end
       end
 
@@ -243,25 +235,26 @@ module Swiftcore
                 last_count += 1
                 next
               elsif last_count > 0
-                lf.write_nonblock "#{@now}|#{last_sv.join(C_bar)}|Last message repeated #{last_count} times\n"
+                lf.write_nonblock "#{@now}|#{last_sv.join(-"|")}|Last message repeated #{last_count} times\n"
                 last_sv = last_m = nil
                 last_count = 0
               end
-              lf.write_nonblock "#{@now}|#{m.join(C_bar)}\n"
+              lf.write_nonblock "#{@now}|#{m.join(-"|")}\n"
               last_m = m.last
               last_sv = m[0..1]
             else
-              lf.write_nonblock "#{@now}|#{m.join(C_bar)}\n"
+              lf.write_nonblock "#{@now}|#{m.join(-"|")}\n"
             end
             @wcount += 1
           end
-          lf.write_nonblock "#{@now}|#{last_sv.join(C_bar)}|Last message repeated #{last_count} times\n" if cull and last_count > 0
+          lf.write_nonblock "#{@now}|#{last_sv.join(-"|")}|Last message repeated #{last_count} times\n" if cull and last_count > 0
         end
         @queue.each {|service,q| q.clear}
       end
 
       def flush_queue
         @logs.each_value do |l|
+          #if !l.logfile.closed? and l.logfile.fileno > 2
           if l.logfile.fileno > 2
             l.logfile.fdatasync rescue l.logfile.fsync
           end
@@ -269,30 +262,36 @@ module Swiftcore
       end
 
       def key
-        @config[Ckey].to_s
+        @config[-"key"].to_s
       end
 
     end
 
-  end
+    class Log
+      attr_reader :service, :levels, :logfile, :cull
 
-  class Log
-    attr_reader :service, :levels, :logfile, :cull
+      def initialize(spec)
+        @service = spec[-"service"]
+        @levels = spec[-"levels"]
+        @logfile = spec[-"logfile"]
+        @cull = spec[-"cull"]
+      end
 
-    def initialize(spec)
-      @service = spec[Analogger::Cservice]
-      @levels = spec[Analogger::Clevels]
-      @logfile = spec[Analogger::Clogfile]
-      @cull = spec[Analogger::Ccull]
-    end
+      def to_s
+        "service: #{@service}\nlevels: #{@levels.inspect}\nlogfile: #{@logfile}\ncull: #{@cull}\n"
+      end
+
+      def ==(n)
+        n.service == @service &&
+          n.levels == @levels &&
+          n.logfile == @logfile &&
+          n.cull == @cull
+      end
 
-    def to_s
-      "service: #{@service}\nlevels: #{@levels.inspect}\nlogfile: #{@logfile}\ncull: #{@cull}\n"
     end
   end
 
   class AnaloggerProtocol < EventMachine::Connection
-    Ci = 'i'.freeze
     Rcolon = /:/
 
     LoggerClass = Analogger

data/lib/swiftcore/Analogger/AnaloggerProtocol.rb

@@ -3,7 +3,6 @@ module Swiftcore
 
     MaxMessageLength = 8192
     MaxLengthBytes = MaxMessageLength.to_s.length
-    Semaphore = "||"
 
     def setup
       @length = nil
@@ -32,11 +31,11 @@ module Swiftcore
               peer = peer ? ::Socket.unpack_sockaddr_in(peer)[1] : 'UNK'
               if l == ck
                 LoggerClass.add_log([:default, :error, "Max Length Exceeded from #{peer} -- #{l}/#{MaxMessageLength}"])
-                send_data "error: max length exceeded\n"
+                send_data(-"error: max length exceeded\n")
                 close_connection_after_writing
               else
                 LoggerClass.add_log([:default, :error, "checksum failed from #{peer} -- #{l}/#{ck}"])
-                send_data "error: checksum failed\n"
+                send_data(-"error: checksum failed\n")
                 close_connection_after_writing
               end
             end
@@ -54,9 +53,9 @@ module Swiftcore
           unless @authenticated
             if msg.last == LoggerClass.key
               @authenticated = true
-              send_data "accepted\n"
+              send_data(-"accepted\n")
             else
-              send_data "denied\n"
+              send_data(-"denied\n")
               close_connection_after_writing
             end
           else

data/lib/swiftcore/Analogger/Client.rb

@@ -43,17 +43,13 @@ module Swiftcore
     class Client
 
       class FailedToAuthenticate < StandardError
-        def initialize(hots = "UNK", port = 6766)
+        def initialize(hots = -"UNK", port = 6766)
           super("Failed to authenticate to the Analogger server at #{destination}:#{port}")
         end
       end
 
-      Cauthentication = 'authentication'.freeze
-      Ci = 'i'.freeze
-
       MaxMessageLength = 8192
       MaxLengthBytes = MaxMessageLength.to_s.length
-      Semaphore = "||"
       ConnectionFailureTimeout = 86400 * 2 # Log locally for a long time if Analogger server goes down.
       MaxFailureCount = (2**(0.size * 8 - 2) - 1) # Max integer -- i.e. really big
       PersistentQueueLimit = 10737412742 # Default to allowing around 10GB temporary local log storage
@@ -115,15 +111,18 @@ module Swiftcore
 
     #-----
 
-      def initialize(service = 'default', host = '127.0.0.1' , port = 6766, key = nil)
+      def initialize(service = -"default", host = -"127.0.0.1" , port = 6766, key = nil)
         @service = service.to_s
         @key = key
         @host = host
         @port = port
+        @socket = nil
         klass = self.class
         @connection_failure_timeout = klass.connection_failure_timeout
         @max_failure_count = klass.max_failure_count
         @persistent_queue_limit = klass.persistent_queue_limit
+        @destination = nil
+        @reconnection_thread = nil
         @authenticated = false
         @total_count = 0
         @logfile = nil
@@ -173,7 +172,7 @@ module Swiftcore
       end
 
       def tmplog_prefix
-        File.join(Dir.tmpdir, "analogger-SERVICE-PID.log")
+        File.join(Dir.tmpdir, -"analogger-SERVICE-PID.log")
       end
 
       def tmplog
@@ -181,7 +180,7 @@ module Swiftcore
       end
 
       def tmplogs
-        Dir[tmplog_prefix.gsub(/SERVICE/, @service).gsub(/PID/,'*')].sort_by {|f| File.mtime(f)}
+        Dir[tmplog_prefix.gsub(/SERVICE/, @service).gsub(/PID/,-"*")].sort_by {|f| File.mtime(f)}
       end
 
       def tmplog=(val)
@@ -222,7 +221,7 @@ module Swiftcore
 
       def setup_local_logging
         unless @logfile && !@logfile.closed?
-          @logfile = File.open(tmplog,"a+")
+          @logfile = File.open(tmplog,-"a+")
           @destination = :local
         end
       end
@@ -297,7 +296,7 @@ module Swiftcore
 
       def authenticate
         begin
-          _remote_log(@service, Cauthentication, "#{@key}")
+          _remote_log(@service, -"authentication", "#{@key}")
           response = @socket.gets
         rescue Exception
           response = nil
@@ -354,7 +353,7 @@ module Swiftcore
                 records.each_index do |n|
                   record = records[n]
                   next if record =~ /^\#/
-                  service, severity, msg = record.split(":", 3)
+                  service, severity, msg = record.split(-":", 3)
                   msg = msg.chomp.gsub(/\x00\x00/, "\n")
                   begin
                     _remote_log(service, severity, msg)

data/lib/swiftcore/Analogger/version.rb

@@ -1,5 +1,5 @@
 module Swiftcore
   class Analogger
-    VERSION = "0.9.1"
+    VERSION = -"0.9.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: analogger
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - Kirk Haines
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-25 00:00:00.000000000 Z
+date: 2018-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: 1.2.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: 1.2.5
 description: Analogger provides a fast and very stable asynchronous central logging
   service capable of handling heavy logging loads. It has been in production use for
   almost a decade.
@@ -86,7 +86,6 @@ files:
 - external/package.rb
 - external/test_support.rb
 - lib/swiftcore/Analogger.rb
-- lib/swiftcore/Analogger.rb.orig
 - lib/swiftcore/Analogger/AnaloggerProtocol.rb
 - lib/swiftcore/Analogger/Client.rb
 - lib/swiftcore/Analogger/EMClient.rb

data/lib/swiftcore/Analogger.rb.orig

@@ -1,291 +0,0 @@
-require 'socket'
-begin
-	load_attempted ||= false
-	require 'eventmachine'
-	require 'benchmark'
-rescue LoadError => e
-	unless load_attempted
-		load_attempted = true
-		require 'rubygems'
-		retry
-	end
-	raise e
-end
-
-module Swiftcore
-	class Analogger
-		C_colon = ':'.freeze
-		C_bar = '|'.freeze
-		Ccull = 'cull'.freeze
-		Cdaemonize = 'daemonize'.freeze
-		Cdefault = 'default'.freeze
-		Cdefault_log = 'default_log'.freeze
-		Cepoll = 'epoll'.freeze
-		Chost = 'host'.freeze
-		Cinterval = 'interval'.freeze
-		Ckey = 'key'.freeze
-		Ckqueue = 'kqueue'.freeze
-		Clevels = 'levels'.freeze
-		Clogfile = 'logfile'.freeze
-		Clogs = 'logs'.freeze
-		Cpidfile = 'pidfile'.freeze
-		Cport = 'port'.freeze
-		Croll = 'roll'.freeze
-		Croll_age = 'roll_age'.freeze
-		Croll_size = 'roll_size'.freeze
-		Croll_interval = 'roll_interval'.freeze
-		Csecret = 'secret'.freeze
-		Cservice = 'service'.freeze
-		Csyncinterval = 'syncinterval'.freeze
-		DefaultSeverityLevels = ['debug','info','warn','error','fatal'].inject({}){|h,k|h[k]=true;h}
-		TimeFormat = '%Y/%m/%d %H:%M:%S'.freeze
-
-		class NoPortProvided < Exception; def to_s; "The port to bind to was not provided."; end; end
-		class BadPort < Exception
-			def initialize(port)
-				@port = port
-			end
-
-		 	def to_s; "The port provided (#{@port}) is invalid."; end
- 		end
-
-		EXIT_SIGNALS = %w[INT TERM]
-		RELOAD_SIGNALS = %w[HUP]
-
-		class << self
-			def safe_trap(siglist, &operation)
-				(Signal.list.keys & siglist).each {|sig| trap(sig, &operation)}
-			end
-
-			def start(config,protocol = AnaloggerProtocol)
-				@config = config
-				daemonize if @config[Cdaemonize]
-				File.open(@config[Cpidfile],'w+') {|fh| fh.puts $$} if @config[Cpidfile]
-				@logs = Hash.new {|h,k| h[k] = new_log(k)}
-				@queue = Hash.new {|h,k| h[k] = []}
-				postprocess_config_load
-				check_config_settings
-				populate_logs
-				set_config_defaults
-				@rcount = 0
-				@wcount = 0
-				safe_trap(EXIT_SIGNALS) {cleanup;exit}
-				safe_trap(RELOAD_SIGNALS) {cleanup;throw :hup}
-
-				if @config[Cepoll] or @config[Ckqueue]
-					EventMachine.epoll if @config[Cepoll]
-					EventMachine.kqueue if @config[Ckqueue]
-
-					EventMachine.set_descriptor_table_size(4096)
-				end
-
-				EventMachine.run {
-					EventMachine.start_server @config[Chost], @config[Cport], protocol
-					EventMachine.add_periodic_timer(1) {Analogger.update_now}
-					EventMachine.add_periodic_timer(@config[Cinterval]) {write_queue}
-					EventMachine.add_periodic_timer(@config[Csyncinterval]) {flush_queue}
-					EventMachine.add_periodic_timer(@config[Crollinterval]) {roll logs}
-				}
-			end
-
-			def daemonize
-				if (child_pid = fork)
-					puts "PID #{child_pid}" unless @config[Cpidfile]
-					exit!
-				end
-				Process.setsid
-
-			rescue Exception
-				puts "Platform (#{RUBY_PLATFORM}) does not appear to support fork/setsid; skipping"
-			end
-
-			def new_log(facility = Cdefault, levels = @config[Clevels] || DefaultSeverityLevels, log = @config[Cdefault_log], cull = true, roll = @config[Croll], roll_age = @config[Croll_age], roll_size = @config[Croll_size])
-				Log.new({Cservice => facility, Clevels => levels, Clogfile => log, Ccull => cull, Croll => roll, Croll_age => roll_age, Croll_size => roll_size})
-			end
-
-			def cleanup
-				@logs.each do |service,l|
-					l.logfile.fsync if !l.logfile.closed? and l.logfile.fileno > 2
-					l.logfile.close unless l.logfile.closed? or l.logfile.fileno < 3
-				end
-			end
-
-			def roll_logs
-				@logs.each do |service,l|
-				end
-			end
-
-			def update_now
-				@now = Time.now.strftime(TimeFormat)
-			end
-
-			def config
-				@config
-			end
-
-			def config=(conf)
-				@config = conf
-			end
-
-			def populate_logs
-				@config[Clogs].each do |log|
-					next unless log[Cservice]
-					roll = log[Croll] || log[Croll_age] || log[Croll_size] ? true : false
-					if Array === log[Cservice]
-						log[Cservice].each do |loglog|
-							@logs[loglog] = new_log(loglog,log[Clevels],logfile_destination(log[Clogfile]),log[Ccull],roll,log[Croll_age],log[Croll_size])
-						end
-					else
-						@logs[log[Cservice]] = new_log(log[Cservice],log[Clevels],logfile_destination(log[Clogfile]),log[Ccull],roll,log[Croll_age],log[Croll_size])
-					end
-				end
-			end
-
-			def postprocess_config_load
-				@config[Clogs] ||= []
-				if @config[Clevels]
-					@config[Clevels] = normalize_levels(@config[Clevels])
-				end
-
-				@config[Clogs].each do |log|
-					log[Clevels] = normalize_levels(log[Clevels])
-				end
-			end
-
-			def normalize_levels(levels)
-				if String === levels and levels =~ /,/
-					levels.split(/,/).inject({}) {|h,k| h[k.to_s] = true; h}
-				elsif Array === levels
-					levels.inject({}) {|h,k| h[k.to_s] = true; h}
-				elsif levels.nil?
-					DefaultSeverityLevels
-				elsif !(Hash === levels)
-					[levels.to_s => true]
-				else
-					levels
-				end
-			end
-
-			def check_config_settings
-				raise NoPortProvided unless @config[Cport]
-				raise BadPort.new(@config[Cport]) unless @config[Cport].to_i > 0
-			end
-
-			def set_config_defaults
-				@config[Chost] ||= '127.0.0.1'
-				@config[Cinterval] ||= 1
-				@config[Csyncinterval] ||= 60
-				@config[Csyncinterval] = nil if @config[Csyncinterval] == 0
-				@config[Cdefault_log] = @config[Cdefault_log].nil? || @config[Cdefault_log] == '-' ? 'STDOUT' : @config[Cdefault_log]
-				@config[Cdefault_log] = logfile_destination(@config[Cdefault_log])
-				@logs['default'] = new_log
-			end
-
-			def logfile_destination(logfile)
-				# We're reloading if it's already an IO.
-				if logfile.is_a?(IO)
-					return $stdout if logfile == $stdout
-					return $stderr if logfile == $stderr
-					return logfile.reopen(logfile.path, 'ab+')
-				end
-
-				if logfile =~ /^STDOUT$/i
-					$stdout
-				elsif logfile =~ /^STDERR$/i
-					$stderr
-				else
-					File.open(logfile,'ab+')
-				end
-			end
-
-			def add_log(log)
-				@queue[log.first] << log
-				@rcount += 1
-			end
-
-			def write_queue
-				@queue.each do |service,q|
-					last_sv = nil
-					last_m = nil
-					last_count = 0
-					next unless log = @logs[service]
-					lf = log.logfile
-					cull = log.cull
-					levels = log.levels
-					q.each do |m|
-						next unless levels.has_key?(m[1])
-						if cull
-							if m.last == last_m and m[0..1] == last_sv
-								last_count += 1
-								next
-							elsif last_count > 0
-								lf.write_nonblock "#{@now}|#{last_sv.join(C_bar)}|Last message repeated #{last_count} times\n"
-								last_sv = last_m = nil
-								last_count = 0
-							end
-							lf.write_nonblock "#{@now}|#{m.join(C_bar)}\n"
-							last_m = m.last
-							last_sv = m[0..1]
-						else
-							lf.write_nonblock "#{@now}|#{m.join(C_bar)}\n"
-						end
-						@wcount += 1
-					end
-					lf.write_nonblock "#{@now}|#{last_sv.join(C_bar)}|Last message repeated #{last_count} times\n" if cull and last_count > 0
-				end
-				@queue.each {|service,q| q.clear}
-			end
-
-			def flush_queue
-				@logs.each_value {|l| l.logfile.fsync if l.logfile.fileno > 2}
-			end
-
-			def key
-				@config[Ckey].to_s
-			end
-
-		end
-
-	end
-
-	class Log
-		attr_reader :service, :levels, :logfile, :cull, :roll, :roll_age, :roll_size
-
-		def initialize(spec)
-			@service = spec[Analogger::Cservice]
-			@levels = spec[Analogger::Clevels]
-			@logfile = spec[Analogger::Clogfile]
-			@cull = spec[Analogger::Ccull]
-			@roll = spec[Analogger::Croll]
-			@roll_inteval = spec[Analogger::Croll_age]
-			@roll_size = spec[Analogger::Croll_size]
-		end
-
-		def to_s
-			"service: #{@service}\nlevels: #{@levels.inspect}\nlogfile: #{@logfile}\ncull: #{@cull}\n"
-		end
-	end
-
-	class AnaloggerProtocol < EventMachine::Connection
-		Ci = 'i'.freeze
-		Rcolon = /:/
-		MaxMessageLength = 8192
-
-		LoggerClass = Analogger
-
-		def post_init
-			setup
-		end
-
-	end
-end
-
-case RUBY_VERSION
-when /^1.8/
-	require 'swiftcore/Analogger/receive_data_18.rb'
-when /^1.9/
-	require 'swiftcore/Analogger/receive_data_19.rb'
-else
-	raise "We're sorry, but Analogger is not supported for ruby versions prior to 1.8.x (and is untested below 1.8.5)."
-end
-