tapsilog 0.1.0

data/CHANGELOG

@@ -0,0 +1,2 @@
+v0.0.1 Initial fork from internally forked analogger.
+

data/Manifest

@@ -0,0 +1,17 @@
+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

data/README.md

@@ -0,0 +1,69 @@
+## 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.
+
+**Supported adapters**
+  
+  - file - Logs to files, STDOUT or STDERR
+  - mongo - Logs to mongoDB
+
+**Gems required for mongoDB support**
+
+  - mongo
+  - bson
+  - bson_ext
+
+## Usage
+
+**Tapsilog Server**
+  
+  The best way to run tapsilog is to write a config file and call:
+
+    tapsilog -c /path/to/config_file.yml
+
+**Sample Config**
+
+    port: 19080
+    host:
+      - 127.0.0.1
+    socket:
+      - /tmp/tapsilog.sock
+    daemonize: false
+    key: some_serious_key
+
+    syncinterval: 1
+
+    logs:
+      #Currently supports file or mongo
+      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
+      
+      #host: 127.0.0.1
+      #port: 1234
+      #user: root
+      #password: somepassword
+      database: tapsilog
+      
+      services:
+        - service: default
+          target: default # This is the mongodb namespace. For file backend, use the path of log file
+
+        - service: dev.access
+          target: dev.access
+
+        - service: dev.bizsupport
+          target: dev.bizsupport
+
+**Tapsilog Client**
+
+  The tapsilog Logger class quacks like the ruby standard Logger.
+
+**Sample**
+
+    logger = Palmade::Tapsilog::Logger.new('default', '/tmp/tapsilog.sock', 'some_serious_key')
+    logger.level = Palmade::Tapsilog::Logger::DEBUG # defaults to INFO
+    logger.info("I am logging a message.", {:my_name => "tapsilog", :my_number => 2})
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'echoe'
+
+Echoe.new('tapsilog', '0.1.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/*"]
+end

data/bin/tapsilog

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+require 'optparse'
+require 'palmade/tapsilog'
+
+module Palmade
+  class TapsilogExec
+
+    def self.run
+      @@parsed_options ||= parse_options
+      Palmade::Tapsilog::Server.start(@@parsed_options)
+    end
+
+    def self.parse_options(config = {})
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: tapsilog [options]'
+        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
+        end
+        opts.on('-s','--syncinterval [INTERVAL]',String,"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[:default_log] = default
+        end
+        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[: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
+
+loop do
+  catch(:hup) {
+    Palmade::TapsilogExec.run
+  }
+end

data/lib/palmade/tapsilog.rb

@@ -0,0 +1,19 @@
+require 'socket'
+require 'timeout'
+require 'eventmachine'
+
+module Palmade
+  module Tapsilog
+    class Timeout < Exception; end
+
+    autoload :Protocol, File.join(File.dirname(__FILE__), 'tapsilog/protocol')
+    autoload :Server, File.join(File.dirname(__FILE__), 'tapsilog/server')
+    autoload :Adapters, File.join(File.dirname(__FILE__), 'tapsilog/adapters')
+    autoload :Utils, File.join(File.dirname(__FILE__), 'tapsilog/utils')
+
+    autoload :Conn, File.join(File.dirname(__FILE__), 'tapsilog/conn')
+    autoload :Client, File.join(File.dirname(__FILE__), 'tapsilog/client')
+    autoload :Logger, File.join(File.dirname(__FILE__), 'tapsilog/logger')
+
+  end
+end

data/lib/palmade/tapsilog/adapters.rb

@@ -0,0 +1,9 @@
+module Palmade::Tapsilog
+  module Adapters
+
+    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')
+
+  end
+end

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

@@ -0,0 +1,32 @@
+module Palmade::Tapsilog::Adapters
+  class BaseAdapter
+
+    def initialize(config)
+      @config = config
+      initialize_services
+    end
+
+    def write(log_message)
+    end
+
+    def flush
+    end
+
+    def close
+    end
+
+    protected
+
+    def initialize_services
+      @services = {}
+
+      @config[:services].each do |service|
+        service_name = service['service']
+        @services[service_name] = {
+          :target => service['target']
+        }
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,54 @@
+module Palmade::Tapsilog::Adapters
+  class FileAdapter < BaseAdapter
+
+    def write(log_message)
+      service = log_message[1]
+      file = get_file_descriptor(service)
+      file.puts(log_message.join("|"))
+    end
+
+    def flush
+      @services.each do |name, service|
+        fd = service[:file]
+        unless fd.nil?
+          fd.fsync if fd.fileno > 2
+        end
+      end
+    end    
+
+    def close
+      @services.each do |name, service|
+        fd = service[:file]
+        unless fd.nil?
+          fd.close unless fd.closed?
+        end 
+      end
+    end
+
+    protected
+ 
+    def get_file_descriptor(service_name)
+      service_name = (@services[service_name].nil?) ? 'default' : service_name
+      service = @services[service_name]
+
+      if service[:file].nil?
+        service[:file] = open_file_descriptor(service)
+      end
+
+      service[:file]
+    end
+
+    def open_file_descriptor(service)
+      logfile = service[:target]
+
+      if logfile =~ /^STDOUT$/i
+        $stdout
+      elsif logfile =~ /^STDERR$/i
+        $stderr
+      else
+        File.open(logfile, 'ab+')
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'mongo'
+
+module Palmade::Tapsilog::Adapters
+  class MongoAdapter < BaseAdapter
+
+    def write(log_message)
+      service = log_message[1]
+      coll = get_collection(service)
+
+      coll.insert(log_to_hash(log_message))
+    end
+
+    def close
+      unless @conn.nil?
+        @conn.close if @conn.connected?
+      end
+    end
+
+    protected
+
+    def get_collection(service_name)
+      service_name = (@services[service_name].nil?) ? 'default' : service_name
+      service = @services[service_name]
+
+      db_conn[service[:target]]
+    end
+
+    def log_to_hash(log_message)
+      timestamp, service, pid, severity, message, tags = log_message
+      log_hash = {
+        :timestamp => timestamp,
+        :service => service,
+        :pid => pid,
+        :severity => severity,
+        :message => message,
+        :created_at => Time.now
+      }
+      unless tags.nil? or tags.empty?
+        log_hash[:tags] = Palmade::Tapsilog::Utils::query_string_to_hash(tags)
+      end
+
+      log_hash
+    end
+
+    def db_conn
+      if @db.nil?
+        mongo_conn = Mongo::Connection.new(@config[:host], @config[:port])
+        db_name = @config[:database] || 'tapsilog'
+
+        @db = mongo_conn.db(db_name)
+        if @config[:user] and @config[:password]
+          @db.authenticate(@config[:user], @config[:password])
+        end
+      end
+
+      @db
+    end
+
+
+  end
+end

data/lib/palmade/tapsilog/client.rb

@@ -0,0 +1,48 @@
+module Palmade::Tapsilog
+  class Client
+
+    DEFAULT_OPTIONS = {
+      :async => false
+    }
+
+    def initialize(service = 'default', target = '127.0.0.1:19070', key = nil, instance_key = nil, options = { })
+      @service = service.to_s
+      @instance_key = instance_key
+
+      @target = target
+      @key = key
+
+      @options = DEFAULT_OPTIONS.merge(options)
+      @conn = Palmade::Tapsilog::Conn.new(@target, @key, @options[:async])
+    end
+
+    def log(severity, msg, tags = {}, ts = nil)
+      ts = Time.now if ts.nil?
+      conn_log(severity, msg, tags, ts)
+      self
+    end
+
+    def flush
+      @conn.flush
+    end
+
+    def close
+      @conn.close
+    end
+
+    def closed?
+      @conn.closed?
+    end
+
+    def reconnect
+      @conn.reconnect!
+    end
+
+    protected
+
+    def conn_log(severity, msg, tags = {}, ts = nil)
+      ts = Time.now if ts.nil?
+      @conn.log(@service, @instance_key || $$, severity, msg, tags, ts)
+    end
+  end
+end

data/lib/palmade/tapsilog/conn.rb

@@ -0,0 +1,132 @@
+require 'cgi'
+
+module Palmade::Tapsilog
+  class Conn
+    attr_reader :socket
+
+    MAX_TRIES = 6
+
+    def initialize(target, key, buffered = false)
+      if target =~ /(.+)\:(\d+)$/i
+        @host = $~[1]
+        @port = $~[2]
+      else
+        @host = target
+        @port = nil
+      end
+      @key = key
+      @socket = nil
+      @buffered = buffered
+    end
+
+    def connect(host, port)
+      if @socket.nil? || @socket.closed?
+        real_connect(host, port)
+        log('default', $$, 'authentication', @key)
+      else
+        @socket
+      end
+    end
+
+    def log(service, instance_key, severity, message, tags = {}, ts = nil)
+      tries = 0
+      connect(@host, @port)
+
+      ts = Time.now if ts.nil?
+      tag_string = Utils::hash_to_query_string(tags)
+
+      fullmsg = ":#{service}:#{instance_key}:#{severity}:#{message}:#{tag_string}"
+
+      # Truncate below the 8192 limit on Tapsilog service
+      fullmsg = fullmsg[0,8190] if fullmsg.size > 8190
+
+      len = [fullmsg.length].pack('i')
+
+      begin
+        # first 8-bytes, is len and checksum
+        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")}"
+
+        if tries < MAX_TRIES
+          tries += 1
+          close_possibly_dead_conn(tries)
+          reconnect
+          retry
+        else
+          raise e
+        end
+      end
+
+      len
+    end
+
+    def flush
+      @socket.flush unless @socket.nil?
+    end
+
+    def close
+      @socket.nil? ? nil : @socket.close rescue nil
+    end
+
+    def closed?
+      @socket.nil? ? true : @socket.closed?
+    end
+
+    def reconnect!
+      close unless closed?
+      connect(@host, @port)
+    end
+    alias :reconnect :reconnect!
+
+    protected
+
+    def real_connect(host, port)
+      tries = 0
+      begin
+        if host =~ /^\/(.+)/
+          @socket = UNIXSocket.new(host)
+        else
+          @socket = TCPSocket.new(host, port)
+          @socket.sync = !@buffered
+        end
+        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")}"
+
+        if tries < MAX_TRIES
+          tries += 1
+          close_possibly_dead_conn(tries)
+          retry
+        else
+          raise e
+        end
+      end
+
+      @socket
+    end
+
+    def write(msg, flush = false)
+      conn_timeout do
+        wrtlen = @socket.write(msg)
+      end
+      self.flush if flush
+      @socket
+    end
+
+    def close_possibly_dead_conn(tries = 0)
+      close unless @socket.nil? || closed?
+
+      @socket = nil
+      select(nil,nil,nil, tries * 0.2) if tries > 0
+      @socket
+    end
+
+    def conn_timeout(&block)
+      ::Timeout::timeout(6, Palmade::Tapsilog::Timeout, &block)
+    end
+
+  end
+end

data/lib/palmade/tapsilog/logger.rb

@@ -0,0 +1,87 @@
+module Palmade::Tapsilog
+  class Logger < Client
+    LOG_LEVEL_TEXT = [ 'debug', 'info', 'warn', 'error', 'fatal', 'unknown' ]
+
+    DEBUG, INFO, WARN, ERROR, FATAL, UNKNOWN = (0..5).to_a
+    
+    attr_accessor :level
+
+    def initialize(*args, &block)
+      super(*args, &block)
+      @level = INFO
+    end
+
+    def info?
+      @level <= INFO
+    end
+    
+    def info(progname = nil, tags = {}, &block)
+      add(INFO, nil, progname, tags, &block)
+    end
+    
+    def debug?
+      @level <= DEBUG
+    end
+
+    def debug(progname = nil, tags = {}, &block)
+      add(DEBUG, nil, progname, tags, &block)
+    end
+
+    def error?
+      @level <= ERROR
+    end
+
+    def error(progname = nil, tags = {}, &block)
+      add(ERROR, nil, progname, tags, &block)
+    end
+
+    def fatal?
+      @level <= FATAL
+    end
+
+    def fatal(progname = nil, tags = {}, &block)
+      add(FATAL, nil, progname, tags, &block)
+    end
+
+    def warn?
+      @level <= WARN
+    end
+
+    def warn(progname = nil, tags = {}, &block)
+      add(WARN, nil, progname, tags, &block)
+    end
+
+    def add(severity, message = nil, progname = nil, tags = {}, &block)
+      case severity
+      when 'authentication'
+        return log_without_rails_extensions(severity, message)
+      when String, Symbol
+        severity = LOG_LEVEL_TEXT.index(severity.to_s.downcase) || UNKNOWN
+      when nil
+        severity = UNKNOWN
+      end
+
+      if severity < @level
+        return true
+      end
+
+      log_level_text = LOG_LEVEL_TEXT[severity]
+      progname ||= @service
+      message = if message.nil?
+        if block_given?
+          message = yield
+        else
+          progname
+        end
+      else
+        message.to_s
+      end
+
+      log_without_rails_extensions(log_level_text, message, tags)
+    end
+    
+    alias_method :log_without_rails_extensions, :log
+    alias_method :log, :add
+  end
+end
+

data/lib/palmade/tapsilog/protocol.rb

@@ -0,0 +1,87 @@
+module Palmade::Tapsilog
+  class Protocol < EventMachine::Connection
+    Ci = 'i'.freeze
+    Rcolon = /:/
+    MaxMessageLength = 8192
+
+    LoggerClass = Palmade::Tapsilog::Server
+
+    def post_init
+      setup
+    end
+
+    def setup
+      @length = nil
+      @logchunk = ''
+      @authenticated = nil
+    end
+
+    def receive_data(data)
+      @logchunk << data
+
+      while @length.nil? and @logchunk.length > 7
+        return false unless get_length
+
+        if @length and @logchunk.length > @length
+          get_message
+        end
+      end
+    end
+
+    protected
+
+    def get_length
+      l = @logchunk[0..3].unpack(Ci).first
+      ck = @logchunk[4..7].unpack(Ci).first
+
+      if l == ck and l < MaxMessageLength
+        @length = l +7
+        return true
+      else
+        peer = get_peername
+        peer = (peer ? ::Socket.unpack_sockaddr_in(peer)[1] : 'UNK') rescue 'UNK'
+
+        if l == ck
+          LoggerClass.add_log([:default, $$.to_s, :error, "Max Length Exceeded from #{peer} -- #{l}/#{MaxMessageLength}"])
+        else
+          LoggerClass.add_log([:default, $$.to_s, :error, "Checksum failed from #{peer} -- #{l}/#{ck}"])
+        end
+
+        close_connection
+        return false
+      end
+    end
+
+    def get_message
+      msg = @logchunk.slice!(0..@length).split(Rcolon, 6)
+
+      unless @authenticated
+        @authenticated = authenticate_message(msg)
+      end
+
+      if @authenticated
+        msg[0] = nil
+        msg.shift
+
+        msg[0] = msg[0].to_s.gsub(/[^a-zA-Z0-9\-\_\.]\s/, '').strip
+
+        LoggerClass.add_log(msg)
+        @length = nil
+      end
+    end
+
+    def authenticate_message(msg)
+      if msg[4] == LoggerClass.key
+        return true
+      else
+        peer = get_peername
+        peer = (peer ? ::Socket.unpack_sockaddr_in(peer)[1] : 'UNK') rescue 'UNK'
+
+        LoggerClass.add_log([:default, $$.to_s, :error, "Invalid key from #{peer} -- #{msg.last}"])
+        close_connection
+        return false
+      end
+    end
+
+  end
+end

data/lib/palmade/tapsilog/server.rb

@@ -0,0 +1,151 @@
+module Palmade::Tapsilog
+  class Server
+
+    SeverityLevels = [:debug, :info, :warn, :error, :fatal]
+
+    attr_reader :now
+
+    def self.start(config, protocol = Palmade::Tapsilog::Protocol)
+      @config = config
+      @protocol = protocol
+      @tsocks = []
+      @usocks = []
+      @queue = []
+      boot
+    end
+
+    def self.add_log(log)
+      @queue << ([@now] + log)
+    end
+
+    def self.key
+      @config[:key].to_s
+    end
+
+    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 }
+
+      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"
+        end
+      end
+
+      File.open(@config[Cpidfile],'w+') {|fh| fh.puts $$}
+    end
+
+    def self.daemonize
+      if (child_pid = fork)
+        puts "Forked PID #{child_pid}"
+        exit!
+      end
+      Process.setsid
+
+    rescue Exception
+      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]
+
+      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])
+    end
+
+    def self.start_server
+      prepare_server
+      begin
+        EventMachine.run {
+          start_servers
+          EventMachine.add_periodic_timer(1) { update_now }
+          EventMachine.add_periodic_timer(@config[:interval]) { write_queue }
+          EventMachine.add_periodic_timer(@config[:syncinterval]) { flush_queue }
+        }
+      ensure
+        cleanup
+      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)
+        
+        STDERR.puts "Listening to: #{usock}"
+        EventMachine.start_unix_domain_server(usock, @protocol)
+        File.chmod(0777, usock)
+      end
+      
+      @tsocks.each do |tsock|
+        raise "Port already in use! #{tsock}:#{@config[:port]}" if Utils.is_port_open?(tsock, @config[:port])
+
+        STDERR.puts "Listening to: #{tsock}:#{@config[:port]}"
+        EventMachine.start_server(tsock, @config[:port], @protocol)
+      end
+    end
+
+    def self.cleanup
+      @adapter.close unless @adapter.nil?
+      @usocks.each do |usock|
+        File.delete(usock) if File.exists?(usock)
+      end
+      File.delete(@config[:pidfile]) if @config[:pidfile] and File.exists?(@config[:pidfile])
+    end
+
+    def self.update_now
+      @now = Time.now.strftime('%Y/%m/%d %H:%M:%S')
+    end
+
+    def self.write_queue
+      @queue.each do |log_message|
+        next unless SeverityLevels.include?(log_message[3].to_sym)
+        @adapter.write(log_message)
+      end
+      @queue.clear
+    end
+
+    def self.flush_queue
+      @adapter.flush
+    end
+
+  end
+end

data/lib/palmade/tapsilog/utils.rb

@@ -0,0 +1,138 @@
+require 'cgi'
+
+module Palmade::Tapsilog
+  class Utils
+    
+    def self.is_port_open?(ip, port)
+      begin
+        ::Timeout::timeout(1) do
+          begin
+            s = TCPSocket.new(ip, port)
+            s.close
+            return true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            return false
+          end
+        end
+      rescue ::Timeout::Error
+      end
+
+      return false
+    end
+
+    # Taken from github accumulator/uri
+
+    def self.query_string_to_hash(query_string, options={})
+      defaults = {:notation => :subscript}
+      options = defaults.merge(options)
+      if ![:flat, :dot, :subscript].include?(options[:notation])
+        raise ArgumentError,
+          "Invalid notation. Must be one of: [:flat, :dot, :subscript]."
+      end
+      dehash = lambda do |hash|
+        hash.each do |(key, value)|
+          if value.kind_of?(Hash)
+            hash[key] = dehash.call(value)
+          end
+        end
+        if hash != {} && hash.keys.all? { |key| key =~ /^\d+$/ }
+          hash.sort.inject([]) do |accu, (key, value)|
+            accu << value; accu
+          end
+        else
+          hash
+        end
+      end
+      return nil if query_string == nil
+      return ((query_string.split("&").map do |pair|
+        pair.split("=", -1) if pair && pair != ""
+      end).compact.inject({}) do |accumulator, (key, value)|
+        value = true if value.nil?
+        key = CGI::unescape(key)
+        if value != true
+          value = CGI::unescape(value).gsub(/\+/, " ")
+        end
+        if options[:notation] == :flat
+          if accumulator[key]
+            raise ArgumentError, "Key was repeated: #{key.inspect}"
+          end
+          accumulator[key] = value
+        else
+          if options[:notation] == :dot
+            array_value = false
+            subkeys = key.split(".")
+          elsif options[:notation] == :subscript
+            array_value = !!(key =~ /\[\]$/)
+            subkeys = key.split(/[\[\]]+/)
+          end
+          current_hash = accumulator
+          for i in 0...(subkeys.size - 1)
+            subkey = subkeys[i]
+            current_hash[subkey] = {} unless current_hash[subkey]
+            current_hash = current_hash[subkey]
+          end
+          if array_value
+            current_hash[subkeys.last] = [] unless current_hash[subkeys.last]
+            current_hash[subkeys.last] << value
+          else
+            current_hash[subkeys.last] = value
+          end
+        end
+        accumulator
+      end).inject({}) do |accumulator, (key, value)|
+        accumulator[key] = value.kind_of?(Hash) ? dehash.call(value) : value
+        accumulator
+      end
+    end
+
+    def self.hash_to_query_string(hash)
+      # Check for frozenness
+      if hash == nil
+        return nil
+      end
+      if !hash.respond_to?(:to_hash)
+        raise TypeError, "Can't convert #{hash.class} into Hash."
+      end
+      hash = hash.to_hash
+      hash = hash.map do |key, value|
+        key = key.to_s if key.kind_of?(Symbol)
+        [key, value]
+      end
+      hash.sort! # Useful default for OAuth and caching
+
+      # Algorithm shamelessly stolen from Julien Genestoux, slightly modified
+      buffer = ""
+      stack = []
+      e = lambda do |component|
+        CGI::escape(component.to_s)
+      end
+      hash.each do |key, value|
+        if value.kind_of?(Hash)
+          stack << [key, value]
+        elsif value.kind_of?(Array)
+          stack << [
+            key,
+            value.inject({}) { |accu, x| accu[accu.size.to_s] = x; accu }
+          ]
+        elsif value == true
+          buffer << "#{e.call(key)}&"
+        else
+          buffer << "#{e.call(key)}=#{e.call(value)}&"
+        end
+      end
+      stack.each do |(parent, hash)|
+        (hash.sort_by { |key| key.to_s }).each do |(key, value)|
+          if value.kind_of?(Hash)
+            stack << ["#{parent}[#{key}]", value]
+          elsif value == true
+            buffer << "#{parent}[#{e.call(key)}]&"
+          else
+            buffer << "#{parent}[#{e.call(key)}]=#{e.call(value)}&"
+          end
+        end
+      end
+      buffer.chop
+    end
+
+  end
+end

data/tapsilog.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{tapsilog}
+  s.version = "0.1.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.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.homepage = %q{}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Tapsilog", "--main", "README.md"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{tapsilog}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Hydrid app-level logger from Palmade. Analogger fork.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0"])
+    else
+      s.add_dependency(%q<eventmachine>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<eventmachine>, [">= 0"])
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: tapsilog
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Palmade
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-03 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Hydrid app-level logger from Palmade. Analogger fork.
+email: ""
+executables: 
+- tapsilog
+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/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
+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
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Tapsilog
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: tapsilog
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Hydrid app-level logger from Palmade. Analogger fork.
+test_files: []
+