tapsilog 0.1.0 → 0.2.0

data/CHANGELOG

@@ -1,2 +1,8 @@
-v0.0.1 Initial fork from internally forked analogger.
+v0.2.0
+Improved command line interface
+Includes tapsilog_tail utility
+Added support for autocreate
+Added proxy backend
 
+v0.1.0
+Includes mongoDB support, and support for tagging logs.

data/INSTALL

@@ -0,0 +1,60 @@
+Swiftcore Analogger 0.5
+
+Homepage::  http://analogger.swiftcore.org
+Copyright:: (C) 2007 by Kirk Haines. All Rights Reserved.
+Email:: wyhaines@gmail.com
+
+
+Installation
+------------
+
+To install analogger:
+
+ruby setup.rb
+
+The analogger executable will be installed into the ruby installation's
+bindir, along with server and client libraries into the site_lib.  The
+rdoc documentation will also be generated.
+
+ruby setup.rb --help
+
+to se a full list of options.
+
+
+Quickstart
+----------
+
+To start an Analogger instance, first create a configuration file:
+
+port: 6766
+host: 127.0.0.1
+default_log: /var/log/weblogs/default
+daemonize: true
+syncinterval: 60
+logs:
+- service: bigapp
+  logfile:  /var/log/bigapp
+  cull: true
+- service:
+  - smallapp1
+  - smallapp2
+  logfile: /var/log/smallapps
+  cull: true
+- service: newsletter_sender
+  logfile: /var/log/newsletter.log
+  cull: false
+
+
+Then start the analogger:
+
+/usr/bin/env analogger -c config_file
+
+
+To use the client library to connect to an Analogger instance and send
+logging messages to it:
+
+require 'swiftcore/Analogger/Client'
+
+logger = Swiftcdore::Analogger::Client.new('smallapp1','127.0.0.1','6766')
+
+logger.log('info','This is a log message.')

data/Manifest

@@ -1,13 +1,16 @@
 CHANGELOG
+INSTALL
 Manifest
 README.md
 Rakefile
 bin/tapsilog
+bin/tapsilog_tail
 lib/palmade/tapsilog.rb
 lib/palmade/tapsilog/adapters.rb
 lib/palmade/tapsilog/adapters/base_adapter.rb
 lib/palmade/tapsilog/adapters/file_adapter.rb
 lib/palmade/tapsilog/adapters/mongo_adapter.rb
+lib/palmade/tapsilog/adapters/proxy_adapter.rb
 lib/palmade/tapsilog/client.rb
 lib/palmade/tapsilog/conn.rb
 lib/palmade/tapsilog/logger.rb

data/README.md

@@ -1,4 +1,4 @@
-## Tapsilog, an asynchronous logging service
+# Tapsilog, an asynchronous logging service
 
   Tapsilog is a super customized fork of Analogger. Tapsilog allows you to attach tags to log messages so that it can be searched easily.
   Currently, Tapsilog supports files and mongodb as storage backend.
@@ -7,6 +7,7 @@
   
   - file - Logs to files, STDOUT or STDERR
   - mongo - Logs to mongoDB
+  - proxy - Forwards logs to another tapsilog server
 
 **Gems required for mongoDB support**
 
@@ -14,48 +15,79 @@
   - bson
   - bson_ext
 
+**Compatibility with analogger**
+
+  Tapsilog is mostly compatible with analogger client. Though there is a known quirk.
+  When using the analogger client, text after a colon will be interpreted as a tag.
+  Tapsilog URL encodes and decodes messages to circumvent this.
+ 
 ## Usage
 
 **Tapsilog Server**
   
-  The best way to run tapsilog is to write a config file and call:
-
-    tapsilog -c /path/to/config_file.yml
+  See tapsilog --help for details 
 
-**Sample Config**
+**Sample File/Mongo Config**
 
     port: 19080
     host:
       - 127.0.0.1
     socket:
       - /tmp/tapsilog.sock
-    daemonize: false
-    key: some_serious_key
+    daemonize: true
+    key: the_real_logger
 
     syncinterval: 1
 
-    logs:
-      #Currently supports file or mongo
+    backend:
+      # Can be mongo or file
       adapter: mongo
 
-      #These options are used for mongo backend.
-      #You can leave the host, port, user and password blank and tapsilog connects to your local mongo installation by default
-      
+      # Services not listed in logs section below will automatically be created under this collection (autocreate_namespace.service_name)
+      # If autocreate is off and an unknown service is requested, tapsilog uses the service named 'default'.
+      # If the service 'default' is not specified, tapsilog ignores the request 
+      #
+      # If file adapter is used, this is used to specify the directory where log files named by the service name are created.
+      #autocreate: development
+
+      # You can leave these blank and tapsilog connects using mongodb connection defaults
       #host: 127.0.0.1
       #port: 1234
       #user: root
       #password: somepassword
-      database: tapsilog
+      #database: tapsilog
       
-      services:
-        - service: default
-          target: default # This is the mongodb namespace. For file backend, use the path of log file
+      # For mongo adapter, target refers to the mongodb collection
+      # For file adapter, specify the path of the log file. You can also use stdout and stderr
+    logs:
+      - service: default
+        target: default
+
+      - service: access
+        target: access
+
+      - service: bizsupport
+        target: bizsupport
 
-        - service: dev.access
-          target: dev.access
+**Sample Proxy Config**
+
+    socket:
+      - /tmp/tapsilog_proxy.sock
+    daemonize: true
+    key: some_serious_key
+
+    syncinterval: 1
+
+    backend:
+      adapter: proxy
+
+      # You can connect to the destination tapsilog instance via tcpip or unix domain socket
+      #host: 127.0.0.1
+      #port: 19080
+      #socket: /tmp/tapsilog.sock
 
-        - service: dev.bizsupport
-          target: dev.bizsupport
+      # Specify the authorization key of the tapsilog server to connect to
+      key: the_real_logger
 
 **Tapsilog Client**
 

data/Rakefile

@@ -1,10 +1,16 @@
 require 'echoe'
 
-Echoe.new('tapsilog', '0.1.0') do |p|
+Echoe.new('tapsilog', '0.2.0') do |p|
   p.author         = "Palmade"
   p.project        = "tapsilog"
   p.summary        = "Hydrid app-level logger from Palmade. Analogger fork."
 
   p.dependencies   = ["eventmachine"]
   p.ignore_pattern = ["tmp/*"]
+
+  p.need_tar_gz = false
+  p.need_tgz = true
+
+  p.clean_pattern += [ "pkg", "lib/*.bundle", "*.gem", ".config" ]
+  p.rdoc_pattern = [ 'README', 'LICENSE', 'COPYING', 'lib/**/*.rb', 'doc/**/*.rdoc' ]
 end

data/bin/tapsilog

@@ -2,68 +2,101 @@
 
 require 'yaml'
 require 'optparse'
-require 'palmade/tapsilog'
+require 'rubygems'
 
-module Palmade
+relative_tapsilog_path = File.expand_path(File.join(File.dirname(__FILE__), '../lib/palmade'))
+if File.exists?(relative_tapsilog_path)
+  require File.join(relative_tapsilog_path, 'tapsilog')
+else
+  gem 'tapsilog'
+  require 'palmade/tapsilog'
+end
+
+module Palmade::Tapsilog
   class TapsilogExec
 
-    def self.run
-      @@parsed_options ||= parse_options
-      Palmade::Tapsilog::Server.start(@@parsed_options)
+    @@config = {}
+
+    def self.start
+      loop do
+        catch(:hup) {
+          if File.exists?(@@config[:configfile])
+            config = Utils.symbolize_keys(YAML.load(File.read(@@config[:configfile])))
+            @@config.merge!(config)
+          end
+          Palmade::Tapsilog::Server.start(@@config)
+        }
+      end
+    end
+
+    def self.stop
+      if Utils.pidf_running?(@@config[:pidfile])
+        pid = Utils.pidf_read(@@config[:pidfile])
+        puts "Sending QUIT to #{pid}"
+        Utils.pidf_kill(@@config[:pidfile])
+      else
+        puts "Tapsilog is not running"
+        Utils.pidf_clean(@@config[:pidfile])
+      end
+    end
+
+    def self.restart
+      stop
+      Utils.pidf_clean(@@config[:pidfile])
+      start
+    end
+
+    def self.status
+      if Utils.pidf_running?(@@config[:pidfile])
+        pid = Utils.pidf_read(@@config[:pidfile])
+        puts "Tapsilog is running with pid #{pid}"
+      else
+        puts "Tapsilog is not running"
+        Utils.pidf_clean(@@config[:pidfile])
+      end
     end
 
     def self.parse_options(config = {})
+      option_parser.parse!
+      @@config
+    end
+
+    def self.option_parser
       OptionParser.new do |opts|
-        opts.banner = 'Usage: tapsilog [options]'
+        opts.banner = 'Usage: tapsilog [options] {start|stop|restart|status}'
+
         opts.separator ''
-        opts.on('-c','--config CONFFILE',"The configuration file to read.") do |conf|
-          config = symbolize_keys(YAML.load(File.read(conf)))
-        end
-        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[:host] = host
-        end
-        opts.on('-t','--socket [SOCKET]',String,"The unix domain socket to bind connection to.") do |socket|
-          config[:socket] = socket
-        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]',String,"The interval between queue writes.  Defaults to 1 second.") do |interval|
-          config[:interval] = interval
+
+        @@config[:configfile] = "/etc/tapsilog.yml"
+        opts.on('-c', '--config CONFFILE', "The configuration file to read. (/etc/tapsilog.yml)") do |conf|
+          @@config[:configfile] = conf
         end
-        opts.on('-s','--syncinterval [INTERVAL]',String,"The interval between queue syncs.  Defaults to 60 seconds.") do |interval|
-          config[:syncinterval] = interval
+
+        @@config[:pidfile] = "/var/run/tapsilog.pid"
+        opts.on('-w', '--writepid FILENAME', "The filename to write a PID file to. (/var/run/tapsilog.pid)") do |pidfile|
+          @@config[:pidfile] = pidfile
         end
-        opts.on('-d','--default [PATH]',String,"The default log destination.  Defaults to stdout.") do |default|
-          config[:default_log] = default
+
+        opts.on('-h', '--help', "Show this message") do
+          puts opts
+          exit
         end
-        opts.on('-x','--daemonize',"Tell the Analogger to daemonize itself.") do
-          config[:daemonize] = true
+        opts.on('-v', '--version', "Show version") do
+          puts 'tapsilog 0.2.0'
+          exit
         end
-        opts.on('-w','--writepid [FILENAME]',"The filename to write a PID file to.") do |pidfile|
-          config[:pidfile] = pidfile
-        end.parse!
-      end
-      config
-    end
 
-    def self.symbolize_keys(hash)
-      hash.inject({}){|result, (key, value)|  
-        new_key = key.kind_of?(String) ? key.to_sym : key  
-        new_value = value.kind_of?(Hash) ? symbolize_keys(value) : value  
-        result[new_key] = new_value  
-        result  
-      }
+      end
     end
 
   end
 end
 
-loop do
-  catch(:hup) {
-    Palmade::TapsilogExec.run
-  }
+config = Palmade::Tapsilog::TapsilogExec.parse_options
+
+if ARGV.length == 0
+  puts Palmade::Tapsilog::TapsilogExec.option_parser.help
+else
+  action = ARGV.shift
+  Palmade::Tapsilog::TapsilogExec.send(action)
 end

data/bin/tapsilog_tail

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+require 'optparse'
+require 'rubygems'
+
+config = {}
+
+optparse = OptionParser.new do |opts|
+  opts.banner = 'Usage: tapsilog_tail [options] ServiceName'
+
+  opts.separator ''
+
+  config[:configfile] = "/etc/tapsilog.yml"
+  opts.on('-c', '--config CONFFILE', "The configuration file to read. (/etc/tapsilog.yml)") do |conf|
+    config[:configfile] = conf
+  end
+
+  opts.on('-f', '--follow', "Output appended data as the file grows.") do
+    config[:follow] = true
+  end
+
+  config[:lines] = 10
+  opts.on('-n', '--lines LINES', "Output the last N lines, instead of the last 10.") do |lines|
+    config[:lines] = lines
+  end
+
+  config[:sleep] = 1
+  opts.on('-s', '--sleep S', "With -f, sleep for approximately S seconds. (default 1.0)") do |sec|
+    config[:sleep] = sec
+  end
+
+  opts.on('-h', '--help', "Show this message") do
+    puts opts
+    exit
+  end
+  opts.on('-v', '--version', "Show version") do
+    puts 'tapsilog_tail 0.2.0'
+    exit
+  end
+end
+optparse.parse!
+
+if ARGV.length == 0
+  puts optparse.help
+else
+  tapsilog_config = YAML.load(File.read(config[:configfile]))
+  service = ARGV.shift
+
+  tapsilog_config['backend'] ||= {}
+  tapsilog_backend = tapsilog_config['backend']
+  tapsilog_config['logs'] ||= []
+  adapter = tapsilog_config['backend']['adapter'] || 'file'
+
+  if tapsilog_config['default_log']
+    tapsilog_config['logs'].push({'service' => 'default', 'target' => tapsilog_config['default_log']})
+  end
+
+  services = {}
+  tapsilog_config['logs'].each do |srv|
+    service_name = srv['service']
+    target = srv['target'] || srv['logfile']
+
+    services[service_name] = target
+  end
+
+  if adapter == 'file'
+    command = "tail"
+    command += " -f " if config[:follow]
+    command += " -n #{config[:lines]} " if config[:lines]
+
+    if services[service]
+      tail_target = services[service]
+    else
+      if autocreate = tapsilog_config['autocreate'] || tapsilog_backend['autocreate']
+        tail_target = File.join(autocreate, service)
+      else
+        tail_target = services['default']
+      end
+    end 
+
+    if tail_target.nil?
+      puts "Uknown service #{service}!"
+      exit
+    end
+
+    if tail_target == "stdout" or tail_target == "stderr"
+      puts "Cannot tail #{tail_target}!"
+      exit
+    end
+
+    command += " #{tail_target} "
+    system command
+  elsif adapter == 'mongo'
+    require 'mongo' 
+
+    mongo_conn = Mongo::Connection.new(tapsilog_backend['host'], tapsilog_backend['port'])
+    db_name = tapsilog_backend['database'] || 'tapsilog'
+
+    db = mongo_conn.db(db_name)
+    if tapsilog_backend['user'] and tapsilog_backend['password']
+      db.authenticate(tapsilog_backend['user'], tapsilog_backend['password'])
+    end
+
+    if services[service]
+      tail_target = services[service]
+    else
+      if autocreate = tapsilog_config['autocreate'] || tapsilog_backend['autocreate']
+        tail_target = "#{autocreate}.#{service}"
+      else
+        tail_target = services['default']
+      end
+    end
+
+    if tail_target.nil?
+      puts "Unknown service #{service}!"
+      exit
+    end
+
+    last_id = nil
+    print_entries = lambda do |log_entries|
+      log_entries.each do |log|
+        last_id = log['_id']
+
+        message = [log['timestamp'], log['service'], log['pid'], log['message']]
+        message.push(log['tags'].inspect) unless log['tags'].nil?
+        puts message.join("|")
+      end
+    end
+
+    last_entries = db[tail_target].find({}, :sort => ['_id', :desc], :limit => config[:lines].to_i).to_a.reverse
+    print_entries.call(last_entries)
+
+    if config[:follow]
+      trap("INT") { exit }
+
+      loop do
+        query = last_id ? {'_id' => {'$gt' => last_id}} : {}
+        new_entries = db[tail_target].find(query).to_a
+        print_entries.call(new_entries)
+        
+        sleep(config[:sleep].to_i)
+      end
+    end
+
+  end
+end

data/lib/palmade/tapsilog/adapters.rb

@@ -4,6 +4,7 @@ module Palmade::Tapsilog
     autoload :BaseAdapter, File.join(File.dirname(__FILE__), 'adapters/base_adapter')
     autoload :FileAdapter, File.join(File.dirname(__FILE__), 'adapters/file_adapter')
     autoload :MongoAdapter, File.join(File.dirname(__FILE__), 'adapters/mongo_adapter')
+    autoload :ProxyAdapter, File.join(File.dirname(__FILE__), 'adapters/proxy_adapter')
 
   end
 end

data/lib/palmade/tapsilog/adapters/base_adapter.rb

@@ -22,8 +22,10 @@ module Palmade::Tapsilog::Adapters
 
       @config[:services].each do |service|
         service_name = service['service']
+        target = service['target'] || service['logfile']
+
         @services[service_name] = {
-          :target => service['target']
+          :target => target
         }
       end
     end

data/lib/palmade/tapsilog/adapters/file_adapter.rb

@@ -3,8 +3,14 @@ module Palmade::Tapsilog::Adapters
 
     def write(log_message)
       service = log_message[1]
+      log_message[5] = Palmade::Tapsilog::Utils.hash_to_query_string(log_message[5])
+
       file = get_file_descriptor(service)
-      file.puts(log_message.join("|"))
+      if file
+        file.puts(log_message.join("|"))
+      else
+        STDERR.puts "Unknown service: #{service}"
+      end
     end
 
     def flush
@@ -28,16 +34,30 @@ module Palmade::Tapsilog::Adapters
     protected
  
     def get_file_descriptor(service_name)
-      service_name = (@services[service_name].nil?) ? 'default' : service_name
+      service_name = resolve_service_name(service_name)
       service = @services[service_name]
 
+      return nil if service.nil?
+
       if service[:file].nil?
         service[:file] = open_file_descriptor(service)
       end
-
       service[:file]
     end
 
+    def resolve_service_name(service_name)
+      if @services[service_name].nil?
+        if @config[:autocreate]
+          @services[service_name] = {
+            :target => File.join(@config[:autocreate], service_name)
+          }
+        else
+          return 'default'
+        end
+      end
+      service_name
+    end
+
     def open_file_descriptor(service)
       logfile = service[:target]
 

data/lib/palmade/tapsilog/adapters/mongo_adapter.rb

@@ -7,7 +7,11 @@ module Palmade::Tapsilog::Adapters
       service = log_message[1]
       coll = get_collection(service)
 
-      coll.insert(log_to_hash(log_message))
+      if coll
+        coll.insert(log_to_hash(log_message))
+      else
+        STDERR.puts "Unknown service: #{service}"
+      end
     end
 
     def close
@@ -19,12 +23,27 @@ module Palmade::Tapsilog::Adapters
     protected
 
     def get_collection(service_name)
-      service_name = (@services[service_name].nil?) ? 'default' : service_name
+      service_name = resolve_service_name(service_name)
       service = @services[service_name]
 
+      return nil if service.nil?
+
       db_conn[service[:target]]
     end
 
+    def resolve_service_name(service_name)
+      if @services[service_name].nil?
+        if @config[:autocreate]
+          @services[service_name] = {
+            :target => "#{@config[:autocreate]}.#{service_name}"
+          }
+        else
+          return 'default'
+        end
+      end
+      service_name
+    end
+
     def log_to_hash(log_message)
       timestamp, service, pid, severity, message, tags = log_message
       log_hash = {
@@ -36,7 +55,7 @@ module Palmade::Tapsilog::Adapters
         :created_at => Time.now
       }
       unless tags.nil? or tags.empty?
-        log_hash[:tags] = Palmade::Tapsilog::Utils::query_string_to_hash(tags)
+        log_hash[:tags] = tags
       end
 
       log_hash

data/lib/palmade/tapsilog/adapters/proxy_adapter.rb

@@ -0,0 +1,42 @@
+module Palmade::Tapsilog::Adapters
+  class ProxyAdapter < BaseAdapter
+
+    def initialize(config)
+      super(config)
+    end
+
+    def write(log_message)
+      service = log_message[1]
+      instance_key = log_message[2]
+      severity = log_message[3]
+      message = log_message[4]
+      tags = log_message[5]
+
+      conn.log(service, instance_key, severity, message, tags)
+    end
+
+    def flush
+      conn.flush
+    end
+
+    def close
+      conn.close
+    end
+
+    protected
+
+    def conn
+      if @conn.nil?
+        if @config[:socket]
+          target = @config[:socket]
+        else
+          target = "#{@config[:host]}:#{@config[:port]}"
+        end
+        @conn = Palmade::Tapsilog::Conn.new(target, @config[:key])
+        @conn.max_tries = -1
+      end
+      @conn
+    end
+
+  end
+end

data/lib/palmade/tapsilog/conn.rb

@@ -3,8 +3,7 @@ require 'cgi'
 module Palmade::Tapsilog
   class Conn
     attr_reader :socket
-
-    MAX_TRIES = 6
+    attr_accessor :max_tries
 
     def initialize(target, key, buffered = false)
       if target =~ /(.+)\:(\d+)$/i
@@ -17,6 +16,7 @@ module Palmade::Tapsilog
       @key = key
       @socket = nil
       @buffered = buffered
+      @max_tries = 6
     end
 
     def connect(host, port)
@@ -33,7 +33,8 @@ module Palmade::Tapsilog
       connect(@host, @port)
 
       ts = Time.now if ts.nil?
-      tag_string = Utils::hash_to_query_string(tags)
+      tag_string = Utils.hash_to_query_string(tags)
+      message = CGI.escape(message)
 
       fullmsg = ":#{service}:#{instance_key}:#{severity}:#{message}:#{tag_string}"
 
@@ -47,9 +48,9 @@ module Palmade::Tapsilog
         write "#{len}#{len}#{fullmsg}"
       rescue Exception => e
         STDERR.puts "Failed to write to server! Retrying... (#{tries})" +
-                    "#{e.class.name}: #{e.message}\n#{e.backtrace.join("\n")}"
+                    "#{e.class.name}: #{e.message}\n#{e.backtrace.join("\n")}" unless @max_tries == -1
 
-        if tries < MAX_TRIES
+        if @max_tries == -1 || tries < @max_tries
           tries += 1
           close_possibly_dead_conn(tries)
           reconnect
@@ -94,9 +95,9 @@ module Palmade::Tapsilog
         raise "Unable to create socket!" if @socket.nil?
       rescue Exception => e
         STDERR.puts "Failed to establish connection with server! Retrying... (#{tries})" + 
-                    " #{e.class.name}: #{e.message}\n#{e.backtrace.join("\n")}"
+                    " #{e.class.name}: #{e.message}\n#{e.backtrace.join("\n")}" unless @max_tries == -1
 
-        if tries < MAX_TRIES
+        if @max_tries == -1 || tries < @max_tries
           tries += 1
           close_possibly_dead_conn(tries)
           retry

data/lib/palmade/tapsilog/protocol.rb

@@ -1,3 +1,5 @@
+require 'cgi'
+
 module Palmade::Tapsilog
   class Protocol < EventMachine::Connection
     Ci = 'i'.freeze
@@ -64,6 +66,8 @@ module Palmade::Tapsilog
         msg.shift
 
         msg[0] = msg[0].to_s.gsub(/[^a-zA-Z0-9\-\_\.]\s/, '').strip
+        msg[3] = CGI.unescape(msg[3].to_s)
+        msg[4] = Utils::query_string_to_hash(msg[4].to_s)
 
         LoggerClass.add_log(msg)
         @length = nil

data/lib/palmade/tapsilog/server.rb

@@ -25,31 +25,54 @@ module Palmade::Tapsilog
     protected
 
     def self.boot
-      write_pid_file if @config[:pidfile]
-      daemonize if @config[:daemonize]
-
       load_adapter
 
       trap("INT") { exit }
       trap("TERM") { exit }
       trap("HUP") { throw :hup }
 
+      prepare_server
+      daemonize if @config[:daemonize]
+      write_pid_file if @config[:pidfile]
       start_server
     end
 
-    def self.write_pid_file
-      if File.exists?(@config[:pidfile])
-        begin
-          pid = File.read(@config[:pidfile]).strip
-          Process.kill(0, pid.to_i)
-          raise "Another instance of tapsilog seems to be running! (#{pid})"
-        rescue Errno::ESRCH
-          File.delete(@config[Cpidfile])
-          STDERR.puts "Stale PID (#{pid}) removed"
+    def self.load_adapter
+      @config[:backend] ||= {}
+
+      adapter_name = @config[:backend][:adapter] || "file"
+      class_name = "#{adapter_name.capitalize}Adapter"
+      adapter = Palmade::Tapsilog::Adapters.const_get(class_name) 
+
+      adapter_config = @config[:backend]
+      adapter_config[:autocreate] = @config[:autocreate] if @config[:autocreate]
+      adapter_config[:services] = @config[:logs] || []
+
+      if @config[:default_log]
+        adapter_config[:services].push({'service' => 'default', 'target' => @config[:default_log]})
+      end
+
+      @adapter = adapter.new(adapter_config)
+    end
+
+    def self.prepare_server
+      if @config[:socket]
+        @usocks = @config[:socket]
+        @usocks = [ @usocks ] unless @usocks.is_a? Array
+
+        @usocks.each do |usock|
+          raise "Socket file already exists! (#{usock})" if File.exists?(usock)
         end
       end
 
-      File.open(@config[Cpidfile],'w+') {|fh| fh.puts $$}
+      if @config[:host]
+        @tsocks = @config[:host]
+        @tsocks = [ @tsocks ] unless @tsocks.is_a? Array
+
+        @tsocks.each do |tsock|
+          raise "Port already in use! #{tsock}:#{@config[:port]}" if Utils.is_port_open?(tsock, @config[:port])
+        end
+      end
     end
 
     def self.daemonize
@@ -63,19 +86,23 @@ module Palmade::Tapsilog
       puts "Platform (#{RUBY_PLATFORM}) does not appear to support fork/setsid; skipping" 
     end
 
-    def self.load_adapter
-      raise "Missing logs section in config file" unless @config[:logs]
+    def self.write_pid_file
+      if pid = Utils.pidf_read(@config[:pidfile])
+        if Utils.process_running?(pid)
+          raise "Another instance of tapsilog seems to be running! (#{pid})"
+        else
+          Utils.pidf_clean(@config[:pidfile])
+          STDERR.puts "Stale PID (#{pid}) removed"
+        end
+      end
 
-      adapter_name = @config[:logs][:adapter] || "file"
-      class_name = "#{adapter_name.capitalize}Adapter"
-      adapter = Palmade::Tapsilog::Adapters.const_get(class_name) 
-      @adapter = adapter.new(@config[:logs])
+      File.open(@config[:pidfile],'w+') {|fh| fh.puts $$}
     end
 
     def self.start_server
-      prepare_server
       begin
         EventMachine.run {
+          update_now
           start_servers
           EventMachine.add_periodic_timer(1) { update_now }
           EventMachine.add_periodic_timer(@config[:interval]) { write_queue }
@@ -86,26 +113,6 @@ module Palmade::Tapsilog
       end
     end
 
-    def self.prepare_server
-      if @config[:socket]
-        @usocks = @config[:socket]
-        @usocks = [ @usocks ] unless @usocks.is_a? Array
-
-        @usocks.each do |usock|
-          raise "Socket file already exists! (#{usock})" if File.exists?(usock)
-        end
-      end
-
-      if @config[:host]
-        @tsocks = @config[:host]
-        @tsocks = [ @tsocks ] unless @tsocks.is_a? Array
-
-        @tsocks.each do |tsock|
-          raise "Port already in use! #{tsock}:#{@config[:port]}" if Utils.is_port_open?(tsock, @config[:port])
-        end
-      end
-    end
-
     def self.start_servers
       @usocks.each do |usock|
         raise "Socket file already exists! (#{usock})" if File.exists?(usock)

data/lib/palmade/tapsilog/utils.rb

@@ -2,7 +2,16 @@ require 'cgi'
 
 module Palmade::Tapsilog
   class Utils
-    
+   
+    def self.symbolize_keys(hash)
+      hash.inject({}){|result, (key, value)|
+        new_key = key.kind_of?(String) ? key.to_sym : key
+        new_value = value.kind_of?(Hash) ? symbolize_keys(value) : value
+        result[new_key] = new_value
+        result
+      }
+    end
+
     def self.is_port_open?(ip, port)
       begin
         ::Timeout::timeout(1) do
@@ -20,6 +29,70 @@ module Palmade::Tapsilog
       return false
     end
 
+    def self.process_running?(pid)
+      Process.getpgid(pid) != -1
+    rescue Errno::ESRCH
+      false
+    end
+
+    def self.pidf_running?(pid_file)
+      if pid = pidf_read(pid_file)
+        process_running?(pid) ? pid : false
+      else
+        nil
+      end
+    end
+
+    def self.pidf_read(pid_file)
+      if File.exists?(pid_file) && File.file?(pid_file) && pid = File.read(pid_file)
+        pid.to_i
+      else
+        nil
+      end
+    end
+
+    def self.pidf_kill(pid_file, timeout = 30)
+      if timeout == 0
+        pidf_send_signal('INT', pid_file, timeout)
+      else
+        pidf_send_signal('QUIT', pid_file, timeout)
+      end
+    end
+
+    def self.pidf_send_signal(signal, pid_file, timeout = 30)
+      if pid = pidf_read(pid_file)
+        Process.kill(signal, pid)
+        ::Timeout.timeout(timeout) do
+          sleep 0.1 while process_running?(pid)
+        end
+        pid
+      else
+        nil
+      end
+    rescue ::Timeout::Error
+      pidf_force_kill pid_file
+    rescue Interrupt
+      pidf_force_kill pid_file
+    rescue Errno::ESRCH # No such process
+      pidf_force_kill pid_file
+    end
+
+    def self.pidf_force_kill(pid_file)
+      if pid = pidf_read(pid_file)
+        Process.kill("KILL", pid)
+        File.delete(pid_file) if File.exist?(pid_file)
+        pid
+      else
+        nil
+      end
+    end
+
+    def self.pidf_clean(pid_file)
+      unless pidf_running?(pid_file)
+        File.delete(pid_file) if File.exists?(pid_file)
+      end
+    end
+
     # Taken from github accumulator/uri
 
     def self.query_string_to_hash(query_string, options={})

data/tapsilog.gemspec

@@ -2,17 +2,16 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tapsilog}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Palmade"]
-  s.date = %q{2010-09-03}
-  s.default_executable = %q{tapsilog}
+  s.date = %q{2010-09-08}
   s.description = %q{Hydrid app-level logger from Palmade. Analogger fork.}
   s.email = %q{}
-  s.executables = ["tapsilog"]
-  s.extra_rdoc_files = ["CHANGELOG", "README.md", "bin/tapsilog", "lib/palmade/tapsilog.rb", "lib/palmade/tapsilog/adapters.rb", "lib/palmade/tapsilog/adapters/base_adapter.rb", "lib/palmade/tapsilog/adapters/file_adapter.rb", "lib/palmade/tapsilog/adapters/mongo_adapter.rb", "lib/palmade/tapsilog/client.rb", "lib/palmade/tapsilog/conn.rb", "lib/palmade/tapsilog/logger.rb", "lib/palmade/tapsilog/protocol.rb", "lib/palmade/tapsilog/server.rb", "lib/palmade/tapsilog/utils.rb"]
-  s.files = ["CHANGELOG", "Manifest", "README.md", "Rakefile", "bin/tapsilog", "lib/palmade/tapsilog.rb", "lib/palmade/tapsilog/adapters.rb", "lib/palmade/tapsilog/adapters/base_adapter.rb", "lib/palmade/tapsilog/adapters/file_adapter.rb", "lib/palmade/tapsilog/adapters/mongo_adapter.rb", "lib/palmade/tapsilog/client.rb", "lib/palmade/tapsilog/conn.rb", "lib/palmade/tapsilog/logger.rb", "lib/palmade/tapsilog/protocol.rb", "lib/palmade/tapsilog/server.rb", "lib/palmade/tapsilog/utils.rb", "tapsilog.gemspec"]
+  s.executables = ["tapsilog", "tapsilog_tail"]
+  s.extra_rdoc_files = ["lib/palmade/tapsilog.rb", "lib/palmade/tapsilog/adapters.rb", "lib/palmade/tapsilog/adapters/base_adapter.rb", "lib/palmade/tapsilog/adapters/file_adapter.rb", "lib/palmade/tapsilog/adapters/mongo_adapter.rb", "lib/palmade/tapsilog/adapters/proxy_adapter.rb", "lib/palmade/tapsilog/client.rb", "lib/palmade/tapsilog/conn.rb", "lib/palmade/tapsilog/logger.rb", "lib/palmade/tapsilog/protocol.rb", "lib/palmade/tapsilog/server.rb", "lib/palmade/tapsilog/utils.rb"]
+  s.files = ["CHANGELOG", "INSTALL", "Manifest", "README.md", "Rakefile", "bin/tapsilog", "bin/tapsilog_tail", "lib/palmade/tapsilog.rb", "lib/palmade/tapsilog/adapters.rb", "lib/palmade/tapsilog/adapters/base_adapter.rb", "lib/palmade/tapsilog/adapters/file_adapter.rb", "lib/palmade/tapsilog/adapters/mongo_adapter.rb", "lib/palmade/tapsilog/adapters/proxy_adapter.rb", "lib/palmade/tapsilog/client.rb", "lib/palmade/tapsilog/conn.rb", "lib/palmade/tapsilog/logger.rb", "lib/palmade/tapsilog/protocol.rb", "lib/palmade/tapsilog/server.rb", "lib/palmade/tapsilog/utils.rb", "tapsilog.gemspec"]
   s.homepage = %q{}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Tapsilog", "--main", "README.md"]
   s.require_paths = ["lib"]

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Palmade
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-03 00:00:00 +08:00
+date: 2010-09-08 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,17 +34,16 @@ description: Hydrid app-level logger from Palmade. Analogger fork.
 email: ""
 executables: 
 - tapsilog
+- tapsilog_tail
 extensions: []
 
 extra_rdoc_files: 
-- CHANGELOG
-- README.md
-- bin/tapsilog
 - lib/palmade/tapsilog.rb
 - lib/palmade/tapsilog/adapters.rb
 - lib/palmade/tapsilog/adapters/base_adapter.rb
 - lib/palmade/tapsilog/adapters/file_adapter.rb
 - lib/palmade/tapsilog/adapters/mongo_adapter.rb
+- lib/palmade/tapsilog/adapters/proxy_adapter.rb
 - lib/palmade/tapsilog/client.rb
 - lib/palmade/tapsilog/conn.rb
 - lib/palmade/tapsilog/logger.rb
@@ -53,15 +52,18 @@ extra_rdoc_files:
 - lib/palmade/tapsilog/utils.rb
 files: 
 - CHANGELOG
+- INSTALL
 - Manifest
 - README.md
 - Rakefile
 - bin/tapsilog
+- bin/tapsilog_tail
 - lib/palmade/tapsilog.rb
 - lib/palmade/tapsilog/adapters.rb
 - lib/palmade/tapsilog/adapters/base_adapter.rb
 - lib/palmade/tapsilog/adapters/file_adapter.rb
 - lib/palmade/tapsilog/adapters/mongo_adapter.rb
+- lib/palmade/tapsilog/adapters/proxy_adapter.rb
 - lib/palmade/tapsilog/client.rb
 - lib/palmade/tapsilog/conn.rb
 - lib/palmade/tapsilog/logger.rb