analogger 0.5.0 → 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b7e212d5f72a1ed3e46b15cc9967b0b4558b22808215e3a7b3c213fb7ad8aa83
+  data.tar.gz: 41937ddf5b49f6eb741ded33748ea90ecb82139846fc4b002f90495b99b19cb6
+SHA512:
+  metadata.gz: 5edca0ff4568f72164b08e9b2ff87415f56edeadbb308308ef9cc882902e6f1c03ed2a13fd0f0059b69d6f84d0d35a52032af6858c3c6ff4df3f731b8e632555
+  data.tar.gz: 1339888e798a75186b11d8aa27db42ef6ab97b133dc9b4e2c24dcbc486e2f707fe3a762197d6f412654261ce0bdc7b365ef60849fc8463fb2f590054115887bc

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in iowa.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    analogger (0.9.0)
+      eventmachine (~> 1.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    eventmachine (1.2.5)
+    minitest (5.11.1)
+    rake (11.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  analogger!
+  bundler (~> 1.10)
+  minitest (~> 5)
+  rake (~> 11.0)
+
+BUNDLED WITH
+   1.16.1

data/INSTALL

@@ -55,6 +55,6 @@ logging messages to it:
 
 require 'swiftcore/Analogger/Client'
 
-logger = Swiftcdore::Analogger::Client.new('smallapp1','127.0.0.1','6766')
+logger = Swiftcore::Analogger::Client.new('smallapp1','127.0.0.1','6766')
 
 logger.log('info','This is a log message.')

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.libs << "ext"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/analogger.gemspec

@@ -1,41 +1,43 @@
-#####
-# Swiftcore Analogger
-#   http://analogger.swiftcore.org
-#   Copyright 2007 Kirk Haines
-#
-#   Licensed under the Ruby License.  See the README for details.
-#
-#####
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'swiftcore/Analogger/version'
 
-spec = Gem::Specification.new do |s|
-  s.name              = 'analogger'
-  s.author            = %q(Kirk Haines)
-  s.email             = %q(wyhaines@gmail.com)
-  s.version           = '0.5.0'
-  s.summary           = %q(A fast asynchronous logging service and client for Ruby.)
-  s.platform          = Gem::Platform::RUBY
+Gem::Specification.new do |spec|
+  spec.name          = "analogger"
+  spec.version       = Swiftcore::Analogger::VERSION
+  spec.authors       = ["Kirk Haines"]
+  spec.email         = ["wyhaines@gmail.com"]
 
-  s.has_rdoc          = true
-  s.rdoc_options      = %w(--title Swiftcore::Analogger --main README --line-numbers)
-  s.extra_rdoc_files  = %w(README)
+  spec.summary       = %q{Analogger is a fast, stable, simple central asynchronous logging service/client. }
+  spec.description   = %q{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.}
+  spec.homepage      = "https://github.com/wyhaines/analogger"
+  spec.license       = "MIT"
 
-  s.files = Dir['**/*']
-	s.executables = %w(analogger)
-	s.require_paths = %w(src)
+  spec.metadata = {
+    "bug_tracker_uri"   => "https://github.com/wyhaines/analogger/issues",
+    "documentation_uri" => "https://github.com/wyhaines/analogger",
+    "homepage_uri"      => "https://github.com/wyhaines/analogger",
+    "source_code_uri"   => "https://github.com/wyhaines/analogger",
+  }
 
-	s.requirements      << "Eventmachine 0.7.0 or higher."
-	s.add_dependency('eventmachine')
-  s.test_files = ['test/TC_Analogger.rb']
-
-  s.rubyforge_project = %q(analogger)
-  s.homepage          = %q(http://analogger.swiftcore.org/)
-  description         = []
-  File.open("README") do |file|
-    file.each do |line|
-      line.chomp!
-      break if line.empty?
-      description << "#{line.gsub(/\[\d\]/, '')}"
-    end
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
   end
-  s.description = description[1..-1].join(" ")
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.extensions       = %w[]
+  spec.require_paths = ["lib"]
+
+  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"
 end
+

data/bin/analogger

@@ -3,15 +3,16 @@
 require 'yaml'
 require 'optparse'
 begin
-	load_attempted ||= false
-	require 'swiftcore/Analogger'
+  load_attempted ||= false
+  require 'swiftcore/Analogger'
 rescue LoadError => e
-	unless load_attempted
-		load_attempted = true
-		require 'rubygems'
-		retry
-	end
-	raise e
+  unless load_attempted
+    load_attempted = true
+    require 'rubygems'
+    require 'bundler/setup'
+    retry
+  end
+  raise e
 end
 
 #####
@@ -31,64 +32,69 @@ end
 #####
 
 module Swiftcore
-	class AnaloggerExec
-		def self.parse_options(config = {})
-			# Config file to read
-			#
-			# port: 12345
-			# secret: abcdef
-			# interval: 1
-			# default_log: /var/log/emlogger
-			# logs:
-			# - service: client1
-			#   levels: info
-			#   logfile: /foo/bar.txt
-			#   cull: true
-			#   
-			OptionParser.new do |opts|
-				opts.banner = 'Usage: 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
-				end
-				opts.on('-h','--host [HOST]',String,"The host to bind the connection to.") do |host|
-					config[Swiftcore::Analogger::Chost] = host
-				end
+  class AnaloggerExec
+    def self.parse_options(config = {})
+      # Config file to read
+      #
+      # port: 12345
+      # secret: abcdef
+      # interval: 1
+      # default_log: /var/log/emlogger
+      # logs:
+      # - service: client1
+      #   levels: info
+      #   logfile: /foo/bar.txt
+      #   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|
+          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
+        end
+        opts.on('-h', '--host [HOST]', String, "The host to bind the connection to.") do |host|
+          config[Swiftcore::Analogger::Chost] = 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
-				end
-				opts.on('-i','--interval [INTERVAL]',String,"The interval between queue writes.  Defaults to 1 second.") do |interval|
-					config[Swiftcore::Analogger::Cinterval] = interval
-				end
-				opts.on('-s','--syncinterval [INTERVAL]',String,"The interval between queue syncs.  Defaults to 60 seconds.") do |interval|
-					config[Swiftcore::Analogger::Csyncinterval] = interval
-				end
-				opts.on('-d','--default [PATH]',String,"The default log destination.  Defaults to stdout.") do |default|
-					config[Swiftcore::Analogger::Cdefault_log] = default
-				end
-				opts.on('-x','--daemonize',"Tell the Analogger to daemonize itself.") do
-					config[Swiftcore::Analogger::Cdaemonize] = true
-				end
-				opts.on('-w','--writepid [FILENAME]',"The filename to write a PID file to.") do |pidfile|
-					config[Swiftcore::Analogger::Cpidfile] = pidfile || 'analogger.pid'
-				end
-			end.parse!
-			config
-		end
+        opts.on('-k', '--key [KEY]', String, "The secret key that authenticates a valid client session.") do |secret|
+          config[Swiftcore::Analogger::Ckey] = secret
+        end
+        opts.on('-i', '--interval [INTERVAL]', Integer, "The interval between queue writes.  Defaults to 1 second.") do |interval|
+          config[Swiftcore::Analogger::Cinterval] = interval
+        end
+        opts.on('-s', '--syncinterval [INTERVAL]', Integer, "The interval between queue syncs.  Defaults to 60 seconds.") do |interval|
+          config[Swiftcore::Analogger::Csyncinterval] = interval
+        end
+        opts.on('-d', '--default [PATH]', String, "The default log destination.  Defaults to stdout.") do |default|
+          config[Swiftcore::Analogger::Cdefault_log] = default
+        end
+        opts.on('-x', '--daemonize', "Tell the Analogger to daemonize itself.") do
+          config[Swiftcore::Analogger::Cdaemonize] = true
+        end
+        opts.on('-w', '--writepid [FILENAME]', "The filename to write a PID file to.") do |pidfile|
+          config[Swiftcore::Analogger::Cpidfile] = pidfile || 'analogger.pid'
+        end
+        opts.on('-v', '--version', "Show the current version of Analogger.") do
+          puts "Analogger v#{Swiftcore::Analogger::VERSION}"
+          exit
+        end
+      end.parse!
+      config
+    end
 
-		def self.run
-			Swiftcore::Analogger.start(parse_options)
-		end
+    def self.run
+      @@parsed_options ||= parse_options
+      Swiftcore::Analogger.start(@@parsed_options)
+    end
 
-	end
+  end
 end
 
 loop do
-	catch(:hup) {Swiftcore::AnaloggerExec.run}
+  catch(:hup) {Swiftcore::AnaloggerExec.run}
 end

data/external/package.rb

@@ -1,3 +1,4 @@
+require 'rubygems'
 require 'rbconfig'
 require 'fileutils'
 require 'optparse'
@@ -36,9 +37,9 @@ end
 
 def self.config(name)
 	# XXX use pathname
-	prefix = Regexp.quote(Config::CONFIG["prefix"])
-	exec_prefix = Regexp.quote(Config::CONFIG["exec_prefix"])
-	Config::CONFIG[name].gsub(/\A\/?(#{prefix}|#{exec_prefix})\/?/, '')
+	prefix = Regexp.quote(RbConfig::CONFIG["prefix"])
+	exec_prefix = Regexp.quote(RbConfig::CONFIG["exec_prefix"])
+	RbConfig::CONFIG[name].gsub(/\A\/?(#{prefix}|#{exec_prefix})\/?/, '')
 end
 
 SITE_DIRS = {
@@ -70,7 +71,7 @@ MODES = {
 
 
 SETUP_OPTIONS = {:parse_cmdline => true, :load_conf => true, :run_tasks => true}
-RUBY_BIN = File.join(::Config::CONFIG['bindir'],::Config::CONFIG['ruby_install_name']) << ::Config::CONFIG['EXEEXT']
+RUBY_BIN = File.join(::RbConfig::CONFIG['bindir'],::RbConfig::CONFIG['ruby_install_name']) << ::RbConfig::CONFIG['EXEEXT']
 
 def self.setup(version, options = {}, &instructions)
 	prefixes = dirs = nil
@@ -197,9 +198,9 @@ module Actions
 						File.open(tmpfile, 'w', 0755) do |w|
 							first = r.gets
 							return unless SHEBANG_RE =~ first
-							ruby = File.join(::Config::CONFIG['bindir'],::Config::CONFIG['ruby_install_name'])
-							ruby << ::Config::CONFIG['EXEEXT']
-							#w.print first.sub(SHEBANG_RE, '#!' + Config::CONFIG['ruby-prog'])
+							ruby = File.join(::RbConfig::CONFIG['bindir'],::RbConfig::CONFIG['ruby_install_name'])
+							ruby << ::RbConfig::CONFIG['EXEEXT']
+							#w.print first.sub(SHEBANG_RE, '#!' + RbConfig::CONFIG['ruby-prog'])
 							w.print first.sub(SHEBANG_RE, '#!' + ruby)
 							w.write r.read
 						end
@@ -308,7 +309,7 @@ class PackageSpecification_1_0
 			end
 			#TODO: refactor
 			self.class.declare_file_type(args) do |files, ignore_p, opt_rename_info|
-				files.each do |file|
+				(Array === files ? files : [files]).each do |file|
 					next if ignore_p && IGNORE_FILES.any?{|re| re.match(file)}
 					add_file(kind, file, opt_rename_info, &bin_callback)
 				end
@@ -397,7 +398,7 @@ class PackageSpecification_1_0
 	end
 
 	def initialize(prefixes = nil, dirs = nil)
-		@prefix = Config::CONFIG["prefix"].gsub(/\A\//, '')
+		@prefix = RbConfig::CONFIG["prefix"].gsub(/\A\//, '')
 		@translate = {}
 		@prefixes = (prefixes || {}).dup
 		KINDS.each do |kind|
@@ -429,7 +430,7 @@ class PackageSpecification_1_0
 			__send__ kind, Dir["#{kind}/**/*"]
 		end
 		translate(:ext, "ext/*" => "", :inherit => true)
-		ext Dir["ext/**/*.#{Config::CONFIG['DLEXT']}"]
+		ext Dir["ext/**/*.#{RbConfig::CONFIG['DLEXT']}"]
 	end
 
 	# Builds any needed extensions.
@@ -668,5 +669,5 @@ end # module Package
 
 require 'rbconfig'
 def config(x)
-	Config::CONFIG[x]
+	RbConfig::CONFIG[x]
 end

data/external/test_support.rb

@@ -1,3 +1,4 @@
+require "rubygems"
 # A support module for the test suite.  This provides a win32 aware
 # mechanism for doing fork/exec operations.  It requires win32/process
 # to be installed, however.
@@ -6,7 +7,7 @@ module SwiftcoreTestSupport
 	@run_modes = []
 
 	def self.create_process(args)
-		@fork_ok = true unless @fork_ok == false
+		@fork_ok = instance_variable_defined?(:@fork_ok) && @fork_ok == false ? false : true
 		pid = nil
 		begin
 			raise NotImplementedError unless @fork_ok
@@ -16,13 +17,9 @@ module SwiftcoreTestSupport
 			end
 		rescue NotImplementedError
 			@fork_ok = false
-			begin
-				require 'rubygems'
-			rescue LoadError
-			end
 
 			begin
-				require 'win32/process'
+				require "win32/process"
 			rescue LoadError
 				raise "Please install win32-process to run all tests on a Win32 platform.  'gem install win32-process' or http://rubyforge.org/projects/win32utils"
 			end

data/lib/swiftcore/Analogger.rb

@@ -0,0 +1,308 @@
+require 'socket'
+require 'swiftcore/Analogger/version'
+require 'eventmachine'
+require 'benchmark'
+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
+
+    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
+        @server = nil
+        safe_trap(EXIT_SIGNALS) {handle_pending_and_exit}
+        safe_trap(RELOAD_SIGNALS) {cleanup;throw :hup}
+
+
+        #####
+        # This is gross.  EM needs to change so that it defaults to the faster
+        # platform specific methods, allowing the user the option to downgrade
+        # to a simple select() loop if they have a good reason for it.
+        #
+        EventMachine.epoll rescue nil
+        EventMachine.kqueue rescue nil
+        #
+        # End of gross.
+        #
+        # TODO: The above was written YEARS ago. See if EventMachine is smarter, now.
+        #####
+
+        EventMachine.set_descriptor_table_size(4096)
+        EventMachine.run {
+          EventMachine.add_shutdown_hook do
+            write_queue
+            flush_queue
+            cleanup
+          end
+          @server = 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}
+        }
+        exit
+      end
+
+      def daemonize
+        if (child_pid = fork)
+          puts "PID #{child_pid}" unless @config[Cpidfile]
+          exit!
+        end
+        Process.setsid
+
+        exit if fork
+
+      rescue NotImplementedError
+        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})
+      end
+
+      # Before exiting, try to get any logs that are still in memory handled and written to disk.
+      def handle_pending_and_exit
+        EventMachine.stop_server(@server)
+        EventMachine.add_timer(1) do
+          _handle_pending_and_exit
+        end
+      end
+
+      def _handle_pending_and_exit
+        if any_in_queue?
+          write_queue
+          EventMachine.next_tick {_handle_pending_and_exit}
+        else
+          EventMachine.stop
+        end
+      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 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]
+          if Array === log[Cservice]
+            log[Cservice].each do |loglog|
+              @logs[loglog] = new_log(loglog,log[Clevels],logfile_destination(log[Clogfile]),log[Ccull])
+            end
+          else
+            @logs[log[Cservice]] = new_log(log[Cservice],log[Clevels],logfile_destination(log[Clogfile]),log[Ccull])
+          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 any_in_queue?
+        any = 0
+        @queue.each do |service, q|
+          q.each do |m|
+            next unless levels.has_key?(m[1])
+            any += 1
+          end
+        end
+        any > 0 ? any : false
+      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 do |l|
+          if l.logfile.fileno > 2
+            l.logfile.fdatasync rescue l.logfile.fsync
+          end
+        end
+      end
+
+      def key
+        @config[Ckey].to_s
+      end
+
+    end
+
+  end
+
+  class Log
+    attr_reader :service, :levels, :logfile, :cull
+
+    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
+  end
+
+  class AnaloggerProtocol < EventMachine::Connection
+    Ci = 'i'.freeze
+    Rcolon = /:/
+
+    LoggerClass = Analogger
+
+    def post_init
+      setup
+    end
+
+  end
+end
+
+
+