td-logger 0.2.8 → 0.3.0

data/ChangeLog

@@ -1,4 +1,13 @@
 
+== 2011-11-05 version 0.3.0
+
+* Added new API: TD.event
+* Added event presets: TD.event.register, login, pay
+* Added feature to add set attributes to all events: TD.event.attribute
+* Stop to log access logs
+* Use NullLogger when logger is disabled
+
+
 == 2011-10-17 version 0.2.8
 
 * Access logger checks to_msgpack for each values and nested values

data/README.rdoc

@@ -29,67 +29,32 @@ And then add +config/treasure_data.yml+ file as following:
     # disable logging
     test:
 
-=== Logging access logs
+== Logging events
 
-Following information will be logged automatically:
+You can log anytime using 'TD.event.post' method:
 
-* controller name ('controller' column)
-* action name ('action' column)
-* remote host ip address ('remote_addr' column)
-* http status code ('status' column)
-* http referer ('refer' column)
-
-To add information to the log, call 'td_access_log' method in a Controller:
-
-    class YourController < ApplicationController
-      def myaction
-        td_access_log[:column] = "value"
-      end
-    end
-
-Or call 'TreasureData.access_log' method outside of a Controller:
-
-    class MyHelperModule
+    class MyClass
       def mymethod
-        TreasureData.access_log[:column] = "value"
+        TD.event.post('table_name', {:foo=>:bar})
       end
     end
 
+== Rails extension
 
-=== Logging model changes
-
-Add 'td_enable_model_tracer' line to your Model class:
-
-    class MyModel < ActiveRecord::Base
-      td_enable_model_tracer :mytable
-    end
-
-It logs all columns when the model is changed. Use :only option to limit columns to log:
-
-    class MyModel < ActiveRecord::Base
-      td_enable_model_tracer :mytable, :only => [:id, :mycol]
-    end
-
-Alternatively, use :except option to except columns to log:
-
-    class MyModel < ActiveRecord::Base
-      td_enable_model_tracer :mytable, :except => [:created_at]
-    end
-
-Add 'static' option to add constant key-value pairs:
+In rails application, you can use 'TD.event.attribute' to set static attribute to all events:
 
-    class MyModel < ActiveRecord::Base
-      td_enable_model_tracer :mytable, :except => [:created_at], :static => {'model'=>'my'}
+    class ApplicationController
+      def authenticate
+        # set 'uid' attribute to succeeding event logs
+        TD.event.attribute[:uid] = 198
+      end
     end
 
-
-=== Logging other logs
-
-You can log anytime using 'TreasureData.log' method:
-
-    class MyClass
+    class MyController < ApplicationController
       def mymethod
-        TreasureData.log('mytable', {:col1=>"val1", :col2=>"val2"}
+        authenticate()
+        # this event includes 'uid' attribute
+        TD.event.post('table_name', {:foo=>:bar})
       end
     end
 

data/lib/td/logger/agent/rack.rb

@@ -0,0 +1,39 @@
+module TreasureData
+module Logger
+module Agent::Rack
+
+  class Hook
+    @@before = []
+    @@after = []
+
+    def self.before(&block)
+      @@before << block
+    end
+
+    def self.after(&block)
+      @@after << block
+    end
+
+    def initialize(app, options={})
+      @app = app
+    end
+
+    def call(env)
+      @@before.each {|m|
+        m.call(env)
+      }
+
+      result = @app.call(env)
+
+      @@after.each {|m|
+        m.call(env, result)
+      }
+
+      result
+    end
+  end
+
+end
+end
+end
+

data/lib/td/logger/agent/rails/config.rb

@@ -0,0 +1,105 @@
+module TreasureData
+module Logger
+module Agent::Rails
+
+  class Config
+    def initialize(conf)
+      if agent = conf['agent']
+        host, port = agent.split(':',2)
+        port = (port || 24224).to_i
+        @agent_host = host
+        @agent_port = port
+
+        @tag = conf['tag']
+        @tag ||= conf['database']
+        raise "'tag' nor 'database' options are not set" unless @tag
+
+      else
+        @apikey = conf['apikey']
+        raise "'apikey' option is not set" unless @apikey
+
+        @database = conf['database']
+        raise "'database' option is not set" unless @database
+
+        if conf.has_key?('auto_create_table')
+          @auto_create_table = !!conf['auto_create_table']
+        else
+          @auto_create_table = true
+        end
+      end
+
+      @access_log_table = conf['access_log_table']
+    end
+
+    attr_reader :agent_host, :agent_port, :tag
+    attr_reader :apikey, :database, :auto_create_table
+    attr_reader :access_log_table
+
+    def agent_mode?
+      @agent_host != nil
+    end
+
+    def access_log_enabled?
+      !@access_log_table.nil? && !@access_log_table.empty?
+    end
+
+    def self.init
+      logger = ::Rails.logger || ::Logger.new(STDERR)
+      if File.exist?("#{::Rails.root}/#{CONFIG_PATH}")
+        load_file(logger)
+      else
+        load_env(logger)
+      end
+    end
+
+    def self.load_file(logger)
+      require 'yaml'
+      require 'erb'
+
+      begin
+        src = File.read("#{::Rails.root}/#{CONFIG_PATH}")
+        yaml = ERB.new(src).result
+        env_conf = YAML.load(yaml)
+      rescue
+        logger.warn "Can't load #{CONFIG_PATH} file: #{$!}"
+        logger.warn "Disabling Treasure Data event logger."
+        return nil
+      end
+
+      conf = env_conf[::Rails.env]
+      unless conf
+        logger.warn "#{CONFIG_PATH} doesn't include setting for current environment (#{::Rails.env})."
+        logger.warn "Disabling Treasure Data event logger."
+        return nil
+      end
+
+      begin
+        return Config.new(conf)
+      rescue
+        logger.warn "#{CONFIG_PATH}: #{$!}."
+        logger.warn "Disabling Treasure Data event logger."
+        return nil
+      end
+    end
+
+    def self.load_env(logger)
+      apikey = ENV['TREASURE_DATA_API_KEY'] || ENV['TD_API_KEY']
+
+      unless apikey
+        logger.warn "#{CONFIG_PATH} does not exist."
+        logger.warn "Disabling Treasure Data event logger."
+        return nil
+      end
+
+      return Config.new({
+        'apikey' => apikey,
+        'database' => ENV['TREASURE_DATA_DB'] || "rails_#{::Rails.env}",
+        'access_log_table' => ENV['TREASURE_DATA_ACCESS_LOG_TABLE'],
+        'auto_create_table' => true
+      })
+    end
+  end
+
+end
+end
+end

data/lib/td/logger/agent/rails/controller.rb

@@ -1,35 +1,33 @@
 module TreasureData
 module Logger
-module Agent
-  module Rails
+module Agent::Rails
+  module ControllerExtension
 
-    def self.init_controller
-      ActionController::Base.send(:include, ControllerExtension)
+    def self.init
+      ::ActionController::Base.send(:include, self)
     end
 
-    module ControllerExtension
-      if defined?(ActiveSupport::Concern)
-        # Rails 2
-        extend ActiveSupport::Concern
-      else
-        def self.included(mod)
-          im = InstanceMethods
-          cm = ClassMethods
-          mod.class_eval do
-            include im
-            extend cm
-          end
+    if defined?(ActiveSupport::Concern)
+      extend ActiveSupport::Concern
+    else
+      # Rails 2
+      def self.included(mod)
+        im = InstanceMethods
+        cm = ClassMethods
+        mod.class_eval do
+          include im
+          extend cm
         end
       end
+    end
 
-      module InstanceMethods
-        def td_access_log
-          request.env['td.access_log'] ||= {}
-        end
+    module InstanceMethods
+      def event
+        TreasureData::Logger.event
       end
+    end
 
-      module ClassMethods
-      end
+    module ClassMethods
     end
 
   end

data/lib/td/logger/agent/rails/model.rb

@@ -1,93 +1,92 @@
 module TreasureData
 module Logger
-module Agent
-  module Rails
+module Agent::Rails
+  module ModelExtension
 
-    def self.init_model
-      unless defined?(::ActiveRecord)
-        # disable model extension if Rails > 3 and
-        # ActiveRecord is not loaded (other ORM is used)
-        if ::Rails.respond_to?(:version) && ::Rails.version =~ /^3/
-          return
-        end
-        require 'active_record'
+    def self.init
+      # disable model extension ActiveRecord is not loaded
+      # on Rails > 3 (other ORM is used)
+      if !defined?(::ActiveRecord) &&
+          ::Rails.respond_to?(:version) && ::Rails.version =~ /^3/
+        return
       end
-      ::ActiveRecord::Base.send(:include, ModelExtension)
+      require 'active_record'
+      ::ActiveRecord::Base.send(:include, self)
     end
 
-    module ModelExtension
-      if defined?(ActiveSupport::Concern)
-        # Rails 2
-        extend ActiveSupport::Concern
-      else
-        def self.included(mod)
-          im = InstanceMethods
-          cm = ClassMethods
-          mod.class_eval do
-            include im
-            extend cm
-          end
+    if defined?(ActiveSupport::Concern)
+      extend ActiveSupport::Concern
+    else
+      # Rails 2
+      def self.included(mod)
+        im = InstanceMethods
+        cm = ClassMethods
+        mod.class_eval do
+          include im
+          extend cm
         end
       end
+    end
 
-      module InstanceMethods
-      end
+    module InstanceMethods
+    end
 
-      module ClassMethods
-        def td_enable_model_tracer(tag, options={})
-          only = nil
-          except = nil
-          static = {}
+    module ClassMethods
+      def td_enable_model_tracer(tag, options={})
+        only = nil
+        except = nil
+        static = {}
 
-          if o = options[:only]
-            only = case o
+        if o = options[:only]
+          only = case o
+                 when Array
+                   o
+                 else
+                   [o]
+                 end.map {|e| e.to_s }
+        end
+
+        if o = options[:except]
+          except = case o
                    when Array
                      o
                    else
                      [o]
                    end.map {|e| e.to_s }
-          end
-
-          if o = options[:except]
-            except = case o
-                     when Array
-                       o
-                     else
-                       [o]
-                     end.map {|e| e.to_s }
-          end
+        end
 
-          if o = options[:static]
-            o.each_pair {|k,v|
-              static[k.to_s] = v
-            }
-          end
+        if o = options[:static]
+          o.each_pair {|k,v|
+            static[k.to_s] = v
+          }
+        end
 
-          if defined?(after_commit)
-            # Rails 3
-            m = :after_commit
-          else
-            # Rails 2
-            m = :after_save
-          end
+        if defined?(after_commit)
+          # Rails 3
+          m = :after_commit
+        else
+          # Rails 2
+          m = :after_save
+        end
 
-          __send__(m) do |record|
-            data = {}
-            record.attribute_names.each {|name|
-              name = name.to_s
-              if (!only || only.include?(name)) && (!except || !except.include?(name))
-                data[name] = record.read_attribute(name)
-              end
-            }
-            static.each_pair {|k,v|
-              data[k] = v
-            }
-            if time = data['updated_at'] && time.is_a?(Time)
-              data['time'] = time.to_i
-              data.delete('updated_at')
+        __send__(m) do |record|
+          data = {}
+          record.attribute_names.each {|name|
+            name = name.to_s
+            if (!only || only.include?(name)) && (!except || !except.include?(name))
+              data[name] = record.read_attribute(name)
             end
-            TreasureData.log(tag, data)
+          }
+          static.each_pair {|k,v|
+            data[k] = v
+          }
+          time = data['updated_at']
+          if time.is_a?(Time)
+            data.delete('updated_at')
+          else
+            time = Time.now
           end
+          TreasureData::Logger.post(tag, data, time)
         end
       end
     end

data/lib/td/logger/agent/rails.rb

@@ -1,158 +1,50 @@
 module TreasureData
 module Logger
-module Agent
-  module Rails
+module Agent::Rails
 
-    CONFIG_PATH = 'config/treasure_data.yml'
+  CONFIG_PATH = 'config/treasure_data.yml'
 
-    CONFIG_SAMPLE = <<EOF
-# logging to Treasure Data directly
-development:
-  apikey: "YOUR_API_KEY"
-  database: myapp
-  access_log_table: access
-  auto_create_table: true
+  require 'td/logger/agent/rack'
+  require 'td/logger/agent/rails/config'
+  require 'td/logger/agent/rails/controller'
+  #require 'td/logger/agent/rails/model'
 
-# logging via td-agent
-production:
-  agent: "localhost:24224"
-  tag: td.myapp
-  access_log_table: access
-
-# disable logging
-test:
-EOF
-
-    class Config
-      def initialize(conf, rails_config)
-        @rails_config = rails_config
-
-        if agent = conf['agent']
-          host, port = agent.split(':',2)
-          port = (port || 24224).to_i
-          @agent_host = host
-          @agent_port = port
-
-          @tag = conf['tag']
-          @tag ||= conf['database']
-          raise "'tag' nor 'database' options are not set" unless @tag
-
-        else
-          @apikey = conf['apikey']
-          raise "'apikey' option is not set" unless @apikey
-
-          @database = conf['database']
-          raise "'database' option is not set" unless @database
-
-          @auto_create_table = !!conf['auto_create_table']
-        end
-
-        @access_log_table = conf['access_log_table']
-      end
-
-      attr_reader :rails_config
-      attr_reader :agent_host, :agent_port, :tag
-      attr_reader :apikey, :database, :auto_create_table
-      attr_reader :access_log_table
-
-      def agent_mode?
-        @agent_host != nil
-      end
-
-      def access_log_enabled?
-        !@access_log_table.nil? && !@access_log_table.empty?
-      end
+  def self.init(rails)
+    c = Config.init
+    unless c
+      ::TreasureData::Logger.open_null
+      return false
     end
 
-    def self.read_config(rails)
-      require 'yaml'
-      require 'erb'
-      logger = ::Rails.logger || ::Logger.new(STDERR)
-
-      unless File.exist?(CONFIG_PATH)
-        apikey = ENV['TREASURE_DATA_API_KEY'] || ENV['TD_API_KEY']
-        unless apikey
-          logger.warn "TREASURE_DATA_API_KEY environment variable is not set"
-          logger.warn "#{CONFIG_PATH} does not exist."
-          logger.warn "Disabling Treasure Data logger."
-          return
-        end
-        return Config.new({
-          'apikey' => apikey,
-          'database' => ENV['TREASURE_DATA_DB'] || "rails_#{::Rails.env}",
-          'access_log_table' => ENV['TREASURE_DATA_TABLE'] || 'web_access',
-          'auto_create_table' => true
-        }, rails)
-      end
-
-      begin
-        src = File.read("#{::Rails.root}/#{CONFIG_PATH}")
-        yaml = ERB.new(src).result
-        env_conf = YAML.load(yaml)
-      rescue
-        logger.warn "Can't load #{CONFIG_PATH} file: #{$!}"
-        logger.warn "Disabling Treasure Data logger."
-        logger.warn "Example:"
-        logger.warn CONFIG_SAMPLE
-        return
-      end
-
-      conf = env_conf[::Rails.env]
-      unless conf
-        logger.warn "#{CONFIG_PATH} doesn't include setting for current environment (#{::Rails.env})."
-        logger.warn "Disabling Treasure Data logger."
-        return
-      end
-
-      begin
-        return Config.new(conf, rails)
-      rescue
-        logger.warn "#{CONFIG_PATH}: #{$!}."
-        logger.warn "Disabling Treasure Data logger."
-        return
-      end
+    if c.agent_mode?
+      ::TreasureData::Logger.open_agent(c.tag, :host=>c.agent_host, :port=>c.agent_port)
+    else
+      ::TreasureData::Logger.open(c.database, :apikey=>c.apikey, :auto_create_table=>c.auto_create_table)
     end
 
-    def self.init(rails)
-      require 'td/logger/agent/middleware'
-      require 'td/logger/agent/access_log'
-      require 'td/logger/agent/rails/controller'
-      require 'td/logger/agent/rails/model'
-
-      c = read_config(rails)
-      return unless c
+    rails.middleware.use Agent::Rack::Hook
 
-      if c.agent_mode?
-        ::TreasureData.open_agent(c.tag, c.agent_host, c.agent_port)
-      else
-        ::TreasureData.open(c.apikey, c.database, c.auto_create_table)
-      end
-
-      rails.middleware.use Agent::Middleware
-
-      if c.access_log_enabled?
-        Agent.enable_access_log(c)
-      end
-      Agent::Rails.init_controller
-      Agent::Rails.init_model
+    Agent::Rack::Hook.before do |env|
+      TreasureData::Logger.event.attribute.clear
     end
 
+    Agent::Rails::ControllerExtension.init
+    #Agent::Rails::AccessLogger.init(c.access_log_table) if c.access_log_enabled?
+    #Agent::Rails::ModelExtension.init
+
+    true
   end
-end
-end
-end
 
-if defined? ::Rails
   if ::Rails.respond_to?(:version) && ::Rails.version =~ /^3/
-    module TreasureData
-      class Railtie < ::Rails::Railtie
-        initializer "treasure_data_agent.start_plugin" do |app|
-          TreasureData::Logger::Agent::Rails.init(app.config)
-        end
+    class Railtie < ::Rails::Railtie
+      initializer "treasure_data_logger.start_plugin" do |app|
+        TreasureData::Logger::Agent::Rails.init(app.config)
       end
     end
   else
     TreasureData::Logger::Agent::Rails.init(::Rails.configuration)
   end
-end
 
+end
+end
+end

data/lib/td/logger/event.rb

@@ -0,0 +1,61 @@
+module TreasureData
+module Logger
+
+  module Event
+    def self.use(mod)
+      send(:include, mod)
+    end
+  end
+
+  module EventPreset
+    def action(name, record, uid=TD.event.attribute[:uid])
+      unless uid
+        raise ArgumentError, "wrong number of arguments (2 for 3): :uid attribute is required"
+      end
+      post(name, record.merge({:uid=>uid}))
+    end
+
+    def register(uid=TD.event.attribute[:uid])
+      unless uid
+        raise ArgumentError, "wrong number of arguments (0 for 1): :uid attribute is required"
+      end
+      action(:register, {}, uid)
+    end
+
+    def login(uid=TD.event.attribute[:uid])
+      unless uid
+        raise ArgumentError, "wrong number of arguments (0 for 1): :uid attribute is required"
+      end
+      action(:login, {}, uid)
+    end
+
+    def pay(category, sub_category, name, price, count, uid=TD.event.attribute[:uid])
+      unless uid
+        raise ArgumentError, "wrong number of arguments (3 for 4): :uid attribute is required"
+      end
+      action(:pay, {:category=>category, :sub_category=>sub_category, :name=>name, :price=>price, :count=>count}, uid)
+    end
+  end
+
+  Event.use EventPreset
+
+  class EventCollector
+    def initialize
+      @attribute = {}
+    end
+
+    attr_accessor :attribute
+
+    def post(action, record, time=nil)
+      TreasureData::Logger.post(action, @attribute.merge(record), time)
+    end
+
+    include Event
+  end
+
+  def self.event
+    Thread.current[:td_event_collector] ||= EventCollector.new
+  end
+
+end
+end

data/lib/td/logger/{tdlog.rb → td_logger.rb}

@@ -1,4 +1,3 @@
-
 module TreasureData
 module Logger
 
@@ -23,20 +22,31 @@ class TreasureDataLogger < Fluent::Logger::LoggerBase
   end
   extend Finalizable
 
-  def initialize(apikey, tag, auto_create_table)
+  def initialize(tag_prefix, options={})
+    defaults = {
+      :auto_create_table => false,
+    }
+    options = defaults.merge!(options)
+
+    @tag_prefix = tag_prefix
+    @auto_create_table = !!options[:auto_create_table]
+
+    apikey = options[:apikey]
+    unless apikey
+      raise ArgumentError, ":apikey options is required"
+    end
+
     require 'thread'
     require 'stringio'
     require 'zlib'
     require 'msgpack'
+    require 'json'
     require 'time'
     require 'net/http'
     require 'cgi'
     require 'logger'
     require 'td/client'
 
-    @tag = tag
-    @auto_create_table = auto_create_table
-
     @logger = ::Logger.new(STDERR)
     @logger.level = ::Logger::INFO
 
@@ -82,30 +92,14 @@ class TreasureDataLogger < Fluent::Logger::LoggerBase
     end
   end
 
-  def post(tag, record)
-    record[:time] ||= Time.now.to_i
+  def post(tag, record, time=nil)
+    time ||= Time.now
+    record[:time] ||= time.to_i
 
-    tag = "#{@tag}.#{tag}"
+    tag = "#{@tag_prefix}.#{tag}" if @tag_prefix
     db, table = tag.split('.')[-2, 2]
 
-    key = [db, table]
-    @mutex.synchronize do
-      buffer = (@map[key] ||= '')
-      record.to_msgpack(buffer)
-
-      if buffer.size > @chunk_limit
-        @queue << [db, table, buffer]
-        @map.delete(key)
-        @cond.signal
-      end
-
-      # stat upload thread if it's not run
-      unless @upload_thread
-        @upload_thread = Thread.new(&method(:upload_main))
-      end
-    end
-
-    nil
+    add(db, table, record)
   end
 
   def upload_main
@@ -146,6 +140,44 @@ class TreasureDataLogger < Fluent::Logger::LoggerBase
   end
 
   private
+  def add(db, table, msg)
+    begin
+      data = msg.to_msgpack
+    rescue
+      @logger.error("TreasureDataLogger: Can't convert to msgpack: #{msg.inspect}: #{$!}")
+      return false
+    end
+
+    key = [db, table]
+
+    @mutex.synchronize do
+      buffer = (@map[key] ||= '')
+
+      buffer << data
+
+      if buffer.size > @chunk_limit
+        @queue << [db, table, buffer]
+        @map.delete(key)
+        @cond.signal
+      end
+
+      # stat upload thread if it's not run
+      unless @upload_thread
+        @upload_thread = Thread.new(&method(:upload_main))
+      end
+    end
+
+    true
+  end
+
+  def to_msgpack(msg)
+    begin
+      msg.to_msgpack
+    rescue NoMethodError
+      JSON.load(JSON.dump(msg)).to_msgpack
+    end
+  end
+
   def try_flush
     @mutex.synchronize do
       if @queue.empty?
@@ -167,10 +199,10 @@ class TreasureDataLogger < Fluent::Logger::LoggerBase
         flushed = true
       rescue
         if @error_count < @retry_limit
-          @logger.error "Failed to import logs to Treasure Data, retrying: #{$!}"
+          @logger.error "Failed to upload event logs to Treasure Data, retrying: #{$!}"
           @error_count += 1
         else
-          @logger.error "Failed to import logs to Treasure Data, trashed: #{$!}"
+          @logger.error "Failed to upload event logs to Treasure Data, trashed: #{$!}"
           $!.backtrace.each {|bt|
             @logger.info bt
           }
@@ -185,7 +217,7 @@ class TreasureDataLogger < Fluent::Logger::LoggerBase
   end
 
   def upload(db, table, buffer)
-    @logger.debug "Importing logs to #{db}.#{table} table on TreasureData"
+    @logger.debug "Uploading event logs to #{db}.#{table} table on Treasure Data"
     begin
       out = StringIO.new
       Zlib::GzipWriter.wrap(out) {|gz| gz.write buffer }
@@ -196,7 +228,7 @@ class TreasureDataLogger < Fluent::Logger::LoggerBase
       unless @auto_create_table
         raise $!
       end
-      @logger.info "Creating table #{db}.#{table} on TreasureData"
+      @logger.info "Creating table #{db}.#{table} on Treasure Data"
       begin
         @client.create_log_table(db, table)
       rescue TreasureData::NotFoundError
@@ -212,7 +244,7 @@ class TreasureDataLogger < Fluent::Logger::LoggerBase
   end
 
   if ConditionVariable.new.method(:wait).arity == 1
-    #$log.warn "WARNING: Running on Ruby 1.8. Ruby 1.9 is recommended."
+    # "WARNING: Running on Ruby 1.8. Ruby 1.9 is recommended."
     require 'timeout'
     def cond_wait(sec)
       Timeout.timeout(sec) {

data/lib/td/logger/version.rb

@@ -1,7 +1,7 @@
 module TreasureData
 module Logger
 
-VERSION = '0.2.8'
+VERSION = '0.3.0'
 
 end
 end

data/lib/td/logger.rb

@@ -1,31 +1,77 @@
 require 'fluent/logger'
 
 module TreasureData
+module Logger
+  autoload :TreasureDataLogger, 'td/logger/td_logger'
 
-def self.open(apikey, database, auto_create_table=false)
-  require 'td/logger/tdlog'
-  TreasureData::Logger::TreasureDataLogger.open(apikey, database, auto_create_table)
-end
+  @@logger = nil
 
-def self.open_agent(tag, agent_host, agent_port)
-  Fluent::Logger::FluentLogger.open(tag, agent_host, agent_port)
-end
+  def self.open(database, options={})
+    @@logger = TreasureData::Logger::TreasureDataLogger.new(database, options)
+  end
 
-def self.log(tag, record)
-  Fluent::Logger.post(tag, record)
-end
+  def self.open_agent(tag, options={})
+    @@logger = Fluent::Logger::FluentLogger.new(tag, options)
+  end
+
+  def self.open_null
+    @@logger = Fluent::Logger::NullLogger.new
+  end
 
+  def self.post(tag, record, time=nil)
+    @@logger.post(tag, record, time)
+  end
+end
 end
 
 
-class Time
-  def to_msgpack(out = '')
-    to_i.to_msgpack(out)
+# shortcut methods
+module TreasureData
+  require 'td/logger/event'
+
+  def self.open(database, options={})
+    TreasureData::Logger.open(database, options)
+  end
+
+  def self.open_agent(tag, options={})
+    TreasureData::Logger.open_agent(tag, options)
+  end
+
+  def self.open_null
+    TreasureData::Logger.open_null
+  end
+
+  def self.post(tag, record, time=nil)
+    TreasureData::Logger.post(tag, record, time)
+  end
+
+  def self.event
+    TreasureData::Logger.event
+  end
+
+  Event = TreasureData::Logger::Event
+
+  # backward compatibility
+  def self.log(*args)  # :nodoc:
+    TreasureData::Logger.post(*args)
   end
 end
 
+# shortcut constants
+TD = TreasureData
+
+# implement Time#to_msgpack
+unless Time.now.respond_to?(:to_msgpack)
+  class Time
+    def to_msgpack(out='')
+      strftime("%Y-%m-%d %H:%M:%S %z").to_msgpack(out)
+    end
+  end
+end
 
-if defined? Rails
-  require 'td/logger/agent/rails'
+module TreasureData::Logger::Agent
+  if defined? ::Rails
+    require 'td/logger/agent/rails'
+  end
 end
 

metadata

@@ -1,125 +1,91 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: td-logger
-version: !ruby/object:Gem::Version 
-  hash: 7
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 8
-  version: 0.2.8
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Sadayuki Furuhashi
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-10-18 00:00:00 +09:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-11-04 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: msgpack
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70213731736700 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 0
-        - 4
-        - 4
+      - !ruby/object:Gem::Version
         version: 0.4.4
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: td-client
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70213731736700
+- !ruby/object:Gem::Dependency
+  name: td-client
+  requirement: &70213731736040 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 63
-        segments: 
-        - 0
-        - 8
-        - 0
+      - !ruby/object:Gem::Version
         version: 0.8.0
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: fluent-logger
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *70213731736040
+- !ruby/object:Gem::Dependency
+  name: fluent-logger
+  requirement: &70213731735340 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 19
-        segments: 
-        - 0
-        - 3
-        - 0
-        version: 0.3.0
+      - !ruby/object:Gem::Version
+        version: 0.4.0
   type: :runtime
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: *70213731735340
 description: 
 email: 
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - ChangeLog
 - README.rdoc
-files: 
+files:
 - lib/td-logger.rb
 - lib/td/logger.rb
-- lib/td/logger/agent/access_log.rb
-- lib/td/logger/agent/middleware.rb
+- lib/td/logger/agent/rack.rb
 - lib/td/logger/agent/rails.rb
+- lib/td/logger/agent/rails/config.rb
 - lib/td/logger/agent/rails/controller.rb
 - lib/td/logger/agent/rails/model.rb
-- lib/td/logger/tdlog.rb
+- lib/td/logger/event.rb
+- lib/td/logger/td_logger.rb
 - lib/td/logger/version.rb
 - ChangeLog
 - README.rdoc
-has_rdoc: true
 homepage: 
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+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 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Treasure Data logging library for Rails
 test_files: []
-

data/lib/td/logger/agent/access_log.rb

@@ -1,146 +0,0 @@
-
-module TreasureData
-module Logger
-module Agent
-
-  ACCESS_LOG_PARAM_ENV =
-        if defined? ::Rails
-          if ::Rails.respond_to?(:version) && ::Rails.version =~ /^3/
-            # Rails 3
-            'action_dispatch.request.path_parameters'
-          else
-            # Rails 2
-            'action_controller.request.path_parameters'
-          end
-        else
-          # Rack default
-          'rack.routing_args'
-        end
-
-  ACCESS_LOG_PRESET_PARAM_KEYS = {
-    :controller => :controller,
-    :action => :action,
-  }
-
-  class MessagePackedString < String
-    def to_msgpack(out = '')
-      out << self
-    end
-  end
-
-  def self.enable_access_log(config)
-    tag = config.access_log_table
-
-    if config.rails_config.respond_to?(:filter_parameters)
-      filter_parameters = config.rails_config.filter_parameters
-    else
-      filter_parameters = []
-    end
-
-    Middleware.before do |env|
-      record = {}
-      Thread.current['td.access_log'] = record
-      env['td.access_log'] = record
-      env['td.access_time'] = Time.now
-    end
-
-    Middleware.after do |env,result|
-      req = env['action_dispatch.request']
-      if !req || !req.is_a?(Rack::Request)
-        req = Rack::Request.new(env)
-      end
-
-      # ignore OPTIONS request
-      if req.request_method != "OPTIONS"
-        record = env['td.access_log'] || {}
-
-        # 'elapsed' column
-        if access_time = env['td.access_time']
-          unless record.has_key?(:elapsed)
-            record[:elapsed] = Time.now - access_time
-          end
-
-          # always overwrite 'time' column by access time
-          record[:time] = access_time
-        end
-
-        # merge params
-        req.params.each_pair {|key,val|
-          key = key.to_sym
-          if !record.has_key?(key) && !filter_parameters.include?(key)
-            begin
-              record[key] = val.to_msgpack(MessagePackedString.new)
-            rescue
-              # ignore
-            end
-          end
-        }
-
-        # 'method' column
-        if !record.has_key?(:method)
-          record[:method] = req.request_method
-        end
-
-        # 'ip' column
-        unless record.has_key?(:ip)
-          record[:ip] = (env['action_dispatch.remote_ip'] || req.ip).to_s
-        end
-
-        # 'path' column
-        #   requested path before '?'
-        unless record.has_key?(:path)
-          if path = env['REQUEST_URI']
-            if m = /(?:\w{1,10}\:\/\/[^\/]+)?([^\?]*)/.match(path)
-              record[:path] = m[1]
-            end
-          end
-        end
-
-        # 'host' column
-        #   Rack#host_with_port consideres HTTP_X_FORWARDED_HOST
-        unless record.has_key?(:host)
-          record[:host] = req.host_with_port
-        end
-
-        # 'referer' column
-        unless record.has_key?(:referer)
-          if referer = env['HTTP_REFERER']
-            record[:referer] = referer.to_s
-          end
-        end
-
-        # 'agent' column
-        unless record.has_key?(:agent)
-          if agent = env['HTTP_USER_AGENT']
-            record[:agent] = agent
-          end
-        end
-
-        # 'status' column
-        unless record.has_key?(:status)
-          record[:status] = result[0].to_i
-        end
-
-        # 'controller' and 'action' columns
-        if m = env[ACCESS_LOG_PARAM_ENV]
-          ACCESS_LOG_PRESET_PARAM_KEYS.each_pair {|key,val|
-            unless record.has_key?(key)
-              record[key] = m[val] if m[val]
-            end
-          }
-        end
-
-        TreasureData.log(tag, record)
-      end
-    end
-  end
-
-end
-end
-end
-
-module TreasureData
-  def self.access_log
-    Thread.current['td.access_log']
-  end
-end

data/lib/td/logger/agent/middleware.rb

@@ -1,41 +0,0 @@
-
-module TreasureData
-module Logger
-module Agent
-
-
-class Middleware
-  @@before = []
-  @@after = []
-
-  def self.before(&block)
-    @@before << block
-  end
-
-  def self.after(&block)
-    @@after << block
-  end
-
-  def initialize(app, options={})
-    @app = app
-  end
-
-  def call(env)
-    @@before.each {|m|
-      m.call(env)
-    }
-
-    result = @app.call(env)
-
-    @@after.each {|m|
-      m.call(env, result)
-    }
-
-    result
-  end
-end
-
-
-end
-end
-end