logworm_client_amqp 0.8.0

data/CHANGELOG

@@ -0,0 +1,81 @@
+v0.8.0
+	Dropped http for amqp for high scalability and reduce latency
+
+v0.7.2
+    Renamed Rails and Rack configuration commands:
+        lw_disable_request_logging ==> donot_log_requests
+        lw_log_request_headers     ==> log_headers
+        lw_enable_dev_logging      ==> log_in_development
+        
+    Renamed :headers field in web_log to :request_headers
+        
+v0.7.1
+    lw-tail and lw-compute now receive an optional app parameter, for the cases where you want to call command-line tools from a directory other than the app's directory... or when you have more than one Heroku remote/app from the same directory
+
+v0.7.0
+    Eliminated long logs. Instead, there's now a parameter (log_request_headers in Rack, lw_log_request_headers in Rails) to add
+       request and response headers to the web_log. 
+    Cleaned up fields in the web_log table
+
+    Added option to turn off automatic logging of requests (disable_request_logging in Rack, lw_disable_request_logging in Rails)
+    Added option to turn on logging even if in development mode (enable_dev_logging in Rack, lw_enable_dev_logging in Rails)
+
+    Honor filter_parameter_logging switch when used with Rails
+
+    Cleaned up log and flush
+    Cleaned up display of elapsed time for flush
+    Cleaned up call from Rack and Rails, and enforce timeout (1 sec by default)
+    Added unit tests
+    
+v0.6.2
+    Added list_tables command
+    
+v0.6.1
+    Added a bit of documentation
+
+v0.6.0 
+    Add support for querying API: lw_query
+    
+v0.5.6
+    log HEROKU_QUEUE as an integer value
+    
+v0.5.5
+    Added default logging of HEROKU_QUEUE   
+
+v0.5.4
+    Removed obsolete lw-heroku application
+    
+v0.5.3
+    Show nicer error message with tail and compute if the app is not properly configured.
+
+v0.5.2
+    Fixes minor issues with in Rails logging
+
+v0.5.1
+    Fixes minor issues with logging statements sent to console
+    
+v0.5.0
+    Supports new base logworm gem, which can work as a Heroku addon
+    Configuration parameters now stored as URL
+    No error if logworm cannot be properly configured -- lw_log simply ignored
+    No logging in development mode
+    
+v0.4.1
+    Show in console time spent communicating with the server.
+    
+v0.4.0 Added support for running on Rails!
+    To use, add config.gem ‘logworm_client’ to environment.rb
+    Then you can configure in ApplicationController, via logs_requests [:short | :long]+
+    Works from views, models, or controllers.
+    
+v0.3.2 added lw_log method --fixed small issue
+
+v0.3.1 added lw_log method
+
+v0.3.0 ensure gem and dependencies live in gemcutter
+
+v0.2.0 log short requests by default in the rack
+
+v0.1.1 minor changes
+
+v0.1.0 initial version.

data/Manifest

@@ -0,0 +1,18 @@
+CHANGELOG
+Manifest
+README.md
+Rakefile
+bin/lw-compute
+bin/lw-tail
+lib/logworm_client/logger.rb
+lib/logworm_client/rack.rb
+lib/logworm_client/rails.rb
+lib/logworm_client_amqp.rb
+lib/logworm_utils.rb
+lib/logworm_utils/compute.rb
+lib/logworm_utils/tail.rb
+spec/logger_spec.rb
+spec/rack_spec.rb
+spec/rails_spec.rb
+spec/spec.opts
+spec/spec_helper.rb

data/README.md

@@ -0,0 +1,45 @@
+logworm client gem
+------------------
+
+Rails Usage
+-----------
+
+Edit environment.rb and add
+
+<pre><code>config.gem 'logworm_client'</pre></code>
+    
+inside the <code>Rails::Initializer.run</code> block
+
+See http://www.logworm.com/docs/setup
+
+Rack Usage
+----------
+
+<p>Edit your config.ru file and indicate that you want to use logworm's Rack middleware. For example, for a Sinatra application you'd have:</p>
+
+<code><pre>require "myapp"
+require "logworm_client"
+use Logworm::Rack
+run Sinatra::Application
+</pre></code>
+
+See http://www.logworm.com/docs/setup
+
+Configuration Options
+---------------------
+
+See http://www.logworm.com/docs/config
+
+Command-Line tools
+------------------
+
+lw-tail
+-------
+
+See http://www.logworm.com/docs/tail
+
+lw-compute
+----------
+
+See http://www.logworm.com/docs/compute
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'echoe'
+Echoe.new('logworm_client_amqp', '0.8.0') do |p|
+  p.description = "logworm client utilities"
+  p.url = "http://www.logworm.com"
+  p.author = "Pomelo, LLC"
+  p.email  = "schapira@pomelollc.com"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+  p.development_dependencies = ["logworm_amqp >=0.8.0", "json"]
+  p.runtime_dependencies = ["logworm_amqp >=0.8.0", "json"]
+end

data/bin/lw-compute

@@ -0,0 +1,66 @@
+#!/usr/local/bin/ruby
+
+require 'rubygems'
+require 'logworm_utils'
+require 'optparse'
+
+options = {
+  :aggregate_group => [],
+  :conditions => [],
+  :start => nil,
+  :end => nil,
+  :debug => false
+}
+
+option_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options] <log table> <function> <field>"
+
+  opts.on("--app app", String, "Specify the Heroku app") do |app|
+    options[:app] = app.strip 
+  end
+
+  opts.on("-g group", String, "Specify an aggregation group (e.g, hour(_ts_utc), or response.code)") do |k|
+    options[:aggregate_group] = k
+  end
+
+  opts.on("-c condition", String, "Specify a condition to match. May be used multiple times") do |c|
+    options[:conditions] << c.strip 
+  end
+
+  opts.on("-s starttime", String, "Specify the start time for the query") do |c|
+    options[:start] = c.strip 
+  end
+
+  opts.on("-e endtime", String, "Specify the end time for the query") do |c|
+    options[:end] = c.strip 
+  end
+
+  opts.on("-v", "Show debug information") do 
+    options[:debug] = true
+  end
+  
+  opts.on( '-h', '--help', 'Display this screen' ) do
+    puts option_parser.help
+    exit(1)
+  end
+  
+end
+
+# Parse, and get the required <table>
+option_parser.parse!
+if ARGV.size == 3
+  table = ARGV[0].strip
+  function = ARGV[1].strip
+  field = ARGV[2].strip
+elsif ARGV.size == 2
+  table = ARGV[0].strip
+  function = ARGV[1].strip
+else
+  puts option_parser.help
+  exit(1)
+end
+
+# and run
+LogwormCompute.new(table, function, field, options).run
+
+

data/bin/lw-tail

@@ -0,0 +1,84 @@
+#!/usr/local/bin/ruby
+
+require 'rubygems'
+require 'logworm_utils'
+require 'optparse'
+
+def help(option_parser, options)
+  puts option_parser.help
+  puts
+  LogwormTail.list(options)
+end
+
+options = {
+  :limit => 200,
+  :loop => false,
+  :frequency => 10,
+  :fields => [],
+  :conditions => [],
+  :start => nil,
+  :end => nil,
+  :debug => false,
+  :fkat => false
+}
+
+option_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options] <log table>"
+
+  opts.on("--app app", String, "Specify the Heroku app") do |app|
+    options[:app] = app.strip 
+  end
+
+  opts.on("-f [secs]", Integer, 
+          "Continuously check for more data, every [secs] seconds.", "Default: #{options[:frequency]}") do |s| 
+    options[:loop] = true
+    options[:frequency] = s if s
+  end
+
+  opts.on("-r limit", Integer, "Specify how many log entries to fetch.", "Default: #{options[:limit]}") do |n|
+    options[:limit] = n
+  end
+
+  opts.on("-k fields", String, "Specify a comma-separated list of fields to retrieve.") do |k|
+    options[:fields] = k.split(",").map {|f| f.strip}
+  end
+
+  opts.on("-c condition", String, "Specify a condition to match. May be used multiple times") do |c|
+    options[:conditions] << c.strip 
+  end
+
+  opts.on("-s starttime", String, "Specify the start time for the query") do |c|
+    options[:start] = c.strip 
+  end
+
+  opts.on("-e endtime", String, "Specify the end time for the query") do |c|
+    options[:end] = c.strip 
+  end
+
+  opts.on("--flat", "Do not expand log entries when printing them") do 
+    options[:flat] = true
+  end
+
+  opts.on("-v", "Show debug information") do 
+    options[:debug] = true
+  end
+  
+  opts.on( '-h', '--help', 'Display this screen' ) do
+    options[:help] = true
+  end
+  
+end
+
+# Parse, and get the required <table>
+option_parser.parse!
+table = ARGV.pop
+if !table or options[:help]
+  help option_parser, options
+  exit(1)
+end
+table.strip!
+
+# and run
+t = LogwormTail.new(table, options).run
+
+

data/lib/logworm_client/logger.rb

@@ -0,0 +1,93 @@
+require 'json'
+  
+module Logworm
+  class LogwormException < Exception ; end
+
+  class Logger
+    $lr_queue = []
+    
+    ###
+    # Use connection to the backend servers specified in environment variable or config file
+    ###
+    def self.use_default_db
+       $lw_server = DB.from_config
+    end
+    
+    ###
+    # Use a connection to a manually specified server
+    ###
+    def self.use_db(db)
+      $lw_server = db
+    end
+    
+    ###
+    # Returns a reference to the current backend server
+    ###
+    def self.db
+      $lw_server
+    end
+    
+    
+    ###
+    # Starts a new cycle: sets a request_id variable, so that all entries (until flush) share that id
+    ###
+    def self.start_cycle
+      $request_id = "#{Thread.current.object_id}-#{(Time.now.utc.to_f * 1000).to_i}"
+    end
+
+    ###
+    # Record an entry. Not sent to the servers until 'flush' is called
+    #
+    # Warning: may raise Exception if there's a problem. It's up to the called to rescue from it in order to continue the processing
+    # of a web request, for example.
+    ###
+    def self.log(table, values = {})
+      return unless table and (table.is_a? String or table.is_a? Symbol)
+      return unless values.is_a? Hash
+
+      # Turn keys into symbols, delete empty ones, rename conflicting ones
+      kvalues = values.delete_if {|k,v| k.to_s == ""}.map {|k,v| [k.to_sym, v]}
+      kvalues = Hash[*kvalues.flatten]
+      [:_ts, :_ts_utc, :_request_id].each do |k|
+        kvalues["orig_#{k}".to_sym] = kvalues[k] if kvalues.has_key? k
+      end
+      
+      # Add information
+      ts = Time.now.utc
+      kvalues[:_ts_utc]     = (ts.to_f * 1000).to_i
+      kvalues[:_ts]         = ts.strftime("%Y-%m-%dT%H:%M:%SZ")
+      kvalues[:_request_id] = $request_id if $request_id
+      
+      # Enqueue
+      $lr_queue << [table, kvalues]
+    end
+
+    ###
+    # Sends the entries to the server, if configured
+    # Returns the number of entries send, and the time it takes
+    #
+    # Warning: may raise Exception if there's a problem. It's up to the called to rescue from it in order to continue the processing
+    # of a web request, for example.
+    ###
+    def self.flush
+      to_send = $lr_queue.size
+
+      # Return if no entries
+      return [0,0] if to_send == 0 
+
+      # Return if no server
+      unless $lw_server
+        $stderr.puts "\t logworm not configured. #{to_send} entries dropped."
+        $lr_queue = [] 
+        return [0,0]
+      end
+      
+      startTime = Time.now
+      $lw_server.batch_log($lr_queue.to_json)
+      $lr_queue = [] 
+      endTime = Time.now
+      
+      [to_send, (endTime - startTime)]
+    end
+  end
+end

data/lib/logworm_client/rack.rb

@@ -0,0 +1,62 @@
+require 'rack/request'
+
+module Logworm
+  class Rack
+
+    def initialize(app, options = {})
+      @app = app
+      
+      @log_requests = (options[:donot_log_requests].nil? or options[:donot_log_requests] != true)
+      @log_headers  = (options[:log_headers] and options[:log_headers] == true)
+      @dev_logging  = (options[:log_in_development] and options[:log_in_development] == true)
+      Logger.use_default_db
+      @timeout = 1
+    end
+
+    def call(env)
+      return @app.call(env) unless (ENV['RACK_ENV'] == 'production' or (ENV['RACK_ENV'] == 'development' and @dev_logging))
+
+      Logger.start_cycle
+      begin
+        startTime = Time.now 
+        status, response_headers, body = @app.call(env) 
+        appTime = (Time.now - startTime) 
+      ensure
+        log_request(env, status, response_headers, appTime)
+        return [status, response_headers, body] 
+      end
+    end
+    
+    private 
+    def log_request(env, status, response_headers, appTime)
+      method       = env['REQUEST_METHOD']
+      path         = (env['REQUEST_PATH'].nil? or env['REQUEST_PATH'] == "")  ? "/" : env['REQUEST_PATH']
+      ip           = env['REMOTE_ADDR']
+      http_headers = env.reject {|k,v| !(k.to_s =~ /^HTTP/) }
+      queue_size   = env['HTTP_X_HEROKU_QUEUE_DEPTH'].nil? ? -1 : env['HTTP_X_HEROKU_QUEUE_DEPTH'].to_i
+
+      entry = { :summary         => "#{method} #{path} - #{status} #{appTime}", 
+                :request_method  => method,
+                :request_path    => path, 
+                :request_ip      => ip,
+                :input           => ::Rack::Request.new(env).params,
+                :response_status => status, 
+                :profiling       => appTime,
+                :queue_size      => queue_size}
+      entry[:request_headers] = http_headers if @log_headers
+      entry[:response_headers] = response_headers if @log_headers
+      Logger.log(:web_log, entry) if @log_requests
+
+      begin 
+        Timeout::timeout(@timeout) { 
+          sent, elapsed = Logger.flush
+          env['rack.errors'].puts("-- #{sent} logworm entries recorded in #{sprintf('%.4f', elapsed)} seconds") if sent > 0
+        } 
+      rescue Exception => e 
+        # Ignore --nothing we can do. The list of logs may (and most likely will) be preserved for the next request
+        env['rack.errors'].puts("logworm call failed: #{e}")
+      end
+    end
+
+  end
+end

data/lib/logworm_client/rails.rb

@@ -0,0 +1,106 @@
+###
+# Extemds ActionController::Base and aliases the process method, to wrap it with the standard logworm request cycle
+#
+# By default it will automatically log web requests (in a short format) into web_log
+# Can also log headers, if specified
+###
+if defined?(ActionController)
+
+  require 'benchmark'
+
+  ActionController::Base.class_eval do
+    ## Basic settings: log requests, without headers. Use default db, and timeout after 1 second
+    @@log_requests = true
+    @@log_headers  = false
+    @@dev_logging  = false
+    @@timeout = 1
+    Logworm::Logger.use_default_db
+    
+    ###
+    # Disable automatic logging of requests
+    # Use from ApplicationController
+    ###
+    def self.donot_log_requests
+      @@log_requests = false
+    end
+    
+    ###
+    # Log headers with requests
+    # Use from ApplicationController
+    ###
+    def self.log_headers
+      @@log_headers = true
+    end
+    
+    ###
+    # Turn on logging in development mode
+    ###
+    def self.log_in_development
+      @@dev_logging = true
+    end
+    
+    ###
+    # Replaces (and embeds) the default Rails processing of a request. 
+    # Call the original method, logs the request unless disabled, and flushes the logworm list
+    ###
+    def process_with_logworm_log(request, response, method = :perform_action, *arguments)
+      unless (RAILS_ENV == 'production' or (RAILS_ENV == 'development' and @@dev_logging))
+        return process_without_logworm_log(request, response, method, *arguments) 
+      end
+      
+      Logworm::Logger.start_cycle
+      begin
+        startTime = Time.now 
+        response  = process_without_logworm_log(request, response, method, *arguments)
+        appTime   = (Time.now - startTime) 
+      ensure
+        log_request(request, response, appTime)
+        return response
+      end
+    end
+    alias_method_chain :process, :logworm_log
+    
+
+    private
+    def log_request(request, response, appTime)
+      method       = request.env['REQUEST_METHOD']
+      path         = request.env['REQUEST_PATH'].blank? ? "/" : request.env['REQUEST_PATH']
+      ip           = request.env['REMOTE_ADDR']
+      http_headers = request.headers.reject {|k,v| !(k.to_s =~ /^HTTP/) }
+      status       = response.status[0..2]
+      queue_size   = request.env['HTTP_X_HEROKU_QUEUE_DEPTH'].blank? ? -1 : request.env['HTTP_X_HEROKU_QUEUE_DEPTH'].to_i
+
+      entry = { :summary         => "#{method} #{path} - #{status} #{appTime}", 
+                :request_method  => method,
+                :request_path    => path, 
+                :request_ip      => ip,
+                :input           => cleaned_input(request),
+                :response_status => status, 
+                :profiling       => appTime,
+                :queue_size      => queue_size}
+      entry[:request_headers] = http_headers if @@log_headers
+      entry[:response_headers] = response.headers if @@log_headers
+      Logworm::Logger.log(:web_log, entry) if @@log_requests
+
+      begin 
+        Timeout::timeout(@@timeout) { 
+          sent, elapsed = Logworm::Logger.flush
+          Rails.logger.info("#{sent} logworm entries recorded in #{sprintf('%.4f', elapsed)} seconds") if sent > 0
+        } 
+      rescue Exception => e 
+        # Ignore --nothing we can do. The list of logs may (and most likely will) be preserved for the next request
+        Rails.logger.error("logworm call failed: #{e}")
+      end
+    end
+    
+    def cleaned_input(request)
+      pars = request.parameters.clone
+      pars.delete("controller")
+      pars.delete("action")
+      respond_to?(:filter_parameters) ? filter_parameters(pars) : pars
+    end
+    
+  end
+
+end
+

data/lib/logworm_client_amqp.rb

@@ -0,0 +1,62 @@
+require 'logworm'
+
+require 'logworm_client/logger'
+require 'logworm_client/rack'
+require 'logworm_client/rails'
+
+def lw_log (logname, values)
+  Logworm::Logger.log(logname, values)
+end
+
+###
+# Perform a query against the logworm server
+# 
+# Requires a log table, and a query
+# The query can be provided as a JSON string, following the syntax described in http://www.logworm.com/docs/query
+#  or as a Hash of options, with the following keys (all optional)
+#   :fields             => String with a comma-separated list of fields (quoted or not), or Array of Strings
+#   :aggregate_function => String
+#   :aggregate_argument => String
+#   :aggregate_group    => String with a comma-separated list of fields (quoted or not), or Array of Strings
+#   :conditions         => String with comma-separated conditions (in MongoDB syntax), or Array of Strings
+#   :start              => String or Integer (for year)
+#   :end                => String or Integer (for year)
+#   :limit              => String or Integer
+# 
+# See Logworm::QueryBuilder
+# 
+# Returns Hash with
+#  id              ==> id of the query
+#  query_url       ==> URL to GET information about the query
+#  results_url     ==> URL to GET the results for the query
+#  created         ==> First creation of the query
+#  updated         ==> most recent update of the query and/or its results
+#  expires         ==> until that datime, the query won't be rerun against the database
+#  execution_time  ==> time in ms to run the query
+#  results         ==> array of hashmaps. Each element corresponds to a log entry, with its fields
+#
+# raises Logworm::DatabaseException, Logworm::ForbiddenAccessException, Logworm::InvalidQueryException
+# or just a regular Exception if it cannot find the URL to the logging database
+###
+def lw_query(logname, query = {}) 
+  db = Logworm::DB.from_config_or_die                                   # Establish connection to DB
+  query = Logworm::QueryBuilder.new(query).to_json if query.is_a? Hash  # Turn query into proper JSON string
+  query_data = db.query(logname, query)                                 # POST to create query
+  db.results(query_data["results_uri"])                                 # GET from query's results uri
+end
+
+###
+# Returns an array with information about the logging tables in the database
+# Each element in the array has;
+#  :tablename   => The name of the logging table
+#  :url         => The URL for POSTing new log entries
+#  :last_write  => Datetime of last entry
+#  :rows        => Count of entries
+#
+# raises Logworm::DatabaseException, Logworm::ForbiddenAccessException, Logworm::InvalidQueryException
+# or just a regular Exception if it cannot find the URL to the logging database
+###
+def lw_list_logs
+  db = Logworm::DB.from_config_or_die                                   # Establish connection to DB
+  db.tables                                                             # Call tables command
+end

data/lib/logworm_utils/compute.rb

@@ -0,0 +1,66 @@
+class LogwormCompute
+    def initialize(table, function, field, options)
+      @table    = table
+      @function = function
+      @field    = field
+      @options  = options
+
+      @valuefield = @field ? "#{@function}(#{@field})" : @function
+
+      begin
+        @db    = Logworm::DB.from_config_or_die(@options[:app])
+        spec   = {:aggregate_function => @function, :aggregate_argument => @field}.merge(@options)
+        @query = Logworm::QueryBuilder.new(spec)
+      rescue Exception => e
+        $stderr.puts "There was an error: #{e}"
+        exit(-1)
+      end
+      
+    end
+
+    def run
+      # Create a resource for the query
+      begin
+        query_data = @db.query(@table, @query.to_json)
+        url = query_data["results_uri"]
+        rows = @db.results(url + "?nocache=1")["results"]
+      rescue Logworm::DatabaseException, Logworm::ForbiddenAccessException  => e
+        $stderr.puts "Error: #{e}"
+        exit(-1)
+      rescue Logworm::InvalidQueryException => e
+        $stderr.puts "#{e}, #{@query.to_json}"  
+        exit(-1)
+      rescue Exception  => e
+        $stderr.puts "Error: #{e}"
+        exit(-1)
+      end
+
+      if @options[:debug]
+        puts "logworm query: #{@query.to_json}"
+        puts "logworm query url: #{query_data["self_uri"]}"
+        puts "logworm results url: #{url}"
+        puts
+      end
+        
+      if @query.groups.length > 0
+        results = {}
+        rows.each do |r|
+          grp = []
+          @query.groups.each do |g|
+            grp << "#{g}:#{r[g]}"
+          end
+          key = "[#{grp.join(', ')}]"
+          value = r[@function]
+          results[key] = {:value => value, :keys => r.dup}
+          results[key][:keys].delete(@function)
+        end
+        results.keys.sort.each do |k|
+          puts "#{k} \t ==> #{@valuefield} = #{results[k][:value]}"
+        end
+      else
+        puts "#{@valuefield} = #{rows.first[@function]}"
+      end
+      
+    end
+
+end

data/lib/logworm_utils/tail.rb

@@ -0,0 +1,106 @@
+class LogwormTail
+    def initialize(table, options)
+      @table   = table
+      @options = options
+
+      begin
+        @db    = Logworm::DB.from_config_or_die(@options[:app])
+        @query = Logworm::QueryBuilder.new(@options.merge(:force_ts => true))
+      rescue Exception => e
+        $stderr.puts "Error: #{e}"
+        exit(-1)
+      end
+    end
+
+    def self.list(options = {})
+      begin
+        @db    = Logworm::DB.from_config_or_die(options[:app])
+        @tables = @db.tables
+        if @tables and @tables.size > 0
+          puts "The following are the tables that you've created thus far:"
+          @tables.sort {|x,y| x["tablename"] <=> y["tablename"]}.each do |t| 
+            puts "\t - #{t["tablename"]}, #{t["rows"]} rows, last updated on #{date_time(t["last_write"])}"
+          end
+        else
+          puts "You haven't recorded any data yet."
+        end
+      rescue Exception => e
+        $stderr.puts "Error: #{e}"
+        exit(-1)
+      end
+    end
+    
+    def run
+      # Create a resource for the query
+      begin
+        query_data = @db.query(@table, @query.to_json)
+        url = query_data["results_uri"]
+      rescue Logworm::DatabaseException, Logworm::ForbiddenAccessException  => e
+        $stderr.puts "Error: #{e}"
+        exit(-1)
+      rescue Logworm::InvalidQueryException => e
+        $stderr.puts "#{e}"  
+        exit(-1)
+      rescue Exception  => e
+        $stderr.puts "Error: #{e}"
+        exit(-1)
+      end
+
+      if @options[:debug]
+        puts "logworm query: #{@query.to_json}"
+        puts "logworm query url: #{query_data["self_uri"]}"
+        puts "logworm results url: #{url}"
+        puts "refresh frequency: #{@options[:frequency]}" if @options[:loop]
+        puts
+      end
+  
+      while true do
+        begin
+          last_printed = print_rows(@db.results(url + "?nocache=1")["results"], last_printed || nil)
+        rescue Logworm::DatabaseException, Logworm::ForbiddenAccessException  => e
+          $stderr.puts "Error: #{e}"
+          exit(-1)
+        rescue Logworm::InvalidQueryException => e
+          $stderr.puts "#{e}"  
+          exit(-1)
+        rescue Exception  => e
+          $stderr.puts "Error: #{e}"
+          exit(-1)
+        end
+        exit(0) unless @options[:loop]
+        sleep @options[:frequency]
+      end
+    end
+
+  private
+
+    def self.date_time(val)
+      val.gsub(/T/, ' @ ').gsub(/Z/, ' GMT')
+    end
+    
+    def print_rows(rows, last)
+      last = "" if last.nil?
+      rows.reverse.each do |r|
+        next unless r["_ts"]
+        if r["_ts"] > last
+          last = r["_ts"]
+          r.delete("_id") unless @options[:fields].include?("_id")
+          r.delete("_ts") unless @options[:fields].include?("_ts")
+          puts "#{LogwormTail.date_time(last)} ==> "
+          print_row(r)
+        end
+      end
+      last
+    end
+
+    def print_row(r)
+      if @options[:flat]
+        puts "\t" + r.keys.sort.map {|k| "#{k}: #{r[k].inspect}"}.join(', ')
+      else
+        r.keys.sort.each do |k|
+          puts "\t#{k}: #{r[k].inspect}"
+        end
+        puts
+      end
+    end
+end

data/lib/logworm_utils.rb

@@ -0,0 +1,4 @@
+require 'logworm'
+
+require 'logworm_utils/tail'
+require 'logworm_utils/compute'

data/logworm_client_amqp.gemspec

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{logworm_client_amqp}
+  s.version = "0.8.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Pomelo, LLC"]
+  s.date = %q{2010-07-31}
+  s.description = %q{logworm client utilities}
+  s.email = %q{schapira@pomelollc.com}
+  s.executables = ["lw-compute", "lw-tail"]
+  s.extra_rdoc_files = ["CHANGELOG", "README.md", "bin/lw-compute", "bin/lw-tail", "lib/logworm_client/logger.rb", "lib/logworm_client/rack.rb", "lib/logworm_client/rails.rb", "lib/logworm_client_amqp.rb", "lib/logworm_utils.rb", "lib/logworm_utils/compute.rb", "lib/logworm_utils/tail.rb"]
+  s.files = ["CHANGELOG", "Manifest", "README.md", "Rakefile", "bin/lw-compute", "bin/lw-tail", "lib/logworm_client/logger.rb", "lib/logworm_client/rack.rb", "lib/logworm_client/rails.rb", "lib/logworm_client_amqp.rb", "lib/logworm_utils.rb", "lib/logworm_utils/compute.rb", "lib/logworm_utils/tail.rb", "spec/logger_spec.rb", "spec/rack_spec.rb", "spec/rails_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "logworm_client_amqp.gemspec"]
+  s.homepage = %q{http://www.logworm.com}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Logworm_client_amqp", "--main", "README.md"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{logworm_client_amqp}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{logworm client utilities}
+
+  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<logworm_amqp>, [">= 0.8.0"])
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_development_dependency(%q<logworm_amqp>, [">= 0.8.0"])
+      s.add_development_dependency(%q<json>, [">= 0"])
+    else
+      s.add_dependency(%q<logworm_amqp>, [">= 0.8.0"])
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<logworm_amqp>, [">= 0.8.0"])
+      s.add_dependency(%q<json>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<logworm_amqp>, [">= 0.8.0"])
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<logworm_amqp>, [">= 0.8.0"])
+    s.add_dependency(%q<json>, [">= 0"])
+  end
+end

data/spec/logger_spec.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'webmock'
+require 'logworm'
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+$: << File.dirname(__FILE__) + '/../lib'
+require 'logworm_client/logger.rb'
+
+describe Logworm::Logger, " flushing" do
+  before do
+    Logworm::Logger.use_db Logworm::DB.new("logworm://a:b@localhost/c/d/")
+  end
+  
+  it "should only record if it's been initialized" do
+    Logworm::Logger.use_db nil
+    Logworm::Logger.log(:tbl1, :a => 1)
+    Logworm::Logger.flush.should == [0,0]
+  end
+
+  it "should only record if there are entries" do
+    Logworm::Logger.flush.should == [0,0]
+  end
+  
+  it "should try to record it it's initialized and has entries, and then reset" do
+    stub_request(:post, "localhost/log").to_return(:body => {:count => 10, :inserted_at => Time.now}.to_json)
+    Logworm::Logger.log(:tbl1, :a => 1)
+    Logworm::Logger.flush[0].should == 1
+    Logworm::Logger.flush.should == [0,0]
+  end
+  
+end
+

data/spec/rack_spec.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'webmock'
+require 'logworm'
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+$: << File.dirname(__FILE__) + '/../lib'
+require 'logworm_client.rb'
+
+describe Logworm::Rack, " init" do
+  it "should initialize the logger with a default db" do
+    Logworm::Logger.should_receive(:use_default_db)
+    Logworm::Rack.new("xx")
+  end
+end
+

data/spec/rails_spec.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'webmock'
+require 'logworm'
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+$: << File.dirname(__FILE__) + '/../lib'
+
+describe Logworm, " init" do
+  it "should initialize the logger with a default db" do
+    require 'logworm_client/logger.rb'                  # ==> Get Logworm::Logger defined
+    Logworm::Logger.should_receive(:use_default_db)
+
+    require 'action_controller'                         # ==> Get ActionController defined 
+    load 'logworm_client/rails.rb'                      # ==> does class_eval of ActionController (use load to guarantee require)
+  end
+end
+

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format specdoc
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'spec'
+require 'spec/autorun'
+require 'spec/interop/test'
+require 'webmock/rspec'
+
+include WebMock
+

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification 
+name: logworm_client_amqp
+version: !ruby/object:Gem::Version 
+  hash: 63
+  prerelease: false
+  segments: 
+  - 0
+  - 8
+  - 0
+  version: 0.8.0
+platform: ruby
+authors: 
+- Pomelo, LLC
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-31 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: logworm_amqp
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 8
+        - 0
+        version: 0.8.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: logworm_amqp
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 8
+        - 0
+        version: 0.8.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: logworm client utilities
+email: schapira@pomelollc.com
+executables: 
+- lw-compute
+- lw-tail
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- README.md
+- bin/lw-compute
+- bin/lw-tail
+- lib/logworm_client/logger.rb
+- lib/logworm_client/rack.rb
+- lib/logworm_client/rails.rb
+- lib/logworm_client_amqp.rb
+- lib/logworm_utils.rb
+- lib/logworm_utils/compute.rb
+- lib/logworm_utils/tail.rb
+files: 
+- CHANGELOG
+- Manifest
+- README.md
+- Rakefile
+- bin/lw-compute
+- bin/lw-tail
+- lib/logworm_client/logger.rb
+- lib/logworm_client/rack.rb
+- lib/logworm_client/rails.rb
+- lib/logworm_client_amqp.rb
+- lib/logworm_utils.rb
+- lib/logworm_utils/compute.rb
+- lib/logworm_utils/tail.rb
+- spec/logger_spec.rb
+- spec/rack_spec.rb
+- spec/rails_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- logworm_client_amqp.gemspec
+has_rdoc: true
+homepage: http://www.logworm.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Logworm_client_amqp
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 11
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: logworm_client_amqp
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: logworm client utilities
+test_files: []
+