termite 0.0.2 → 0.0.10

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+source "http://gems.sv2"
+
+# Specify your gem's dependencies in your gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    termite (0.0.10)
+      ecology (~> 0.0.6)
+      multi_json
+
+GEM
+  remote: http://rubygems.org/
+  remote: http://gems.sv2/
+  specs:
+    ecology (0.0.7)
+      multi_json
+    minitest (2.3.0)
+    mocha (0.9.12)
+    multi_json (1.0.3)
+    rake (0.9.2)
+    scope (0.2.1)
+      minitest
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.10)
+  mocha
+  rake
+  scope (~> 0.2.1)
+  termite!

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Ooyala, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,131 @@
+Termite
+=======
+
+Termite is a gem to handle local logs.  Specifically, it logs to
+Syslog in a simple component-based manner, records thread IDs and
+serializes JSON data.
+
+It uses, but doesn't depend on, an Ecology file to specify things
+like the default application name and other logging settings.
+
+Installing
+==========
+
+"gem install termite" works pretty well.  You can also specify Termite
+from a Gemfile if you're using Bundler (and you should).
+
+Ooyalans should make sure that "gems.sv2" is listed as a gem source in
+your Gemfile or on your gem command line.
+
+Logging Dynamically
+===================
+
+Create a logger with something like:
+
+  @logger = Termite::Logger.new
+
+Then use it like a regular logger, possibly with options:
+
+  @logger.add(Logger::DEBUG, "so, like, this thing happened, right?", {}, :component => :ValleyGirl)
+  @logger.warn { "And I was like, whoah!" }
+
+You can also pass in JSON data after your message and before your options:
+
+  @logger.fatal("Pain and misery!", { :where_it_hurts => "elbow" }, :component => "WhinyLib")
+  @logger.info("I ache", {:where_it_hurts => "kidney"}, :application => "NotMe", :component => "StoicLib")
+
+Termite also supports full Ruby Logger initialize parameters for backward compatibility:
+
+  @logger = Termite::Logger.new("/var/lib/daily_termite_logs", "daily")
+  @logger = Termite::Logger.new("/tmp/rotatable.txt", 15, 1024000)  # Up to 15 logs of size 1024000
+
+Log Level
+=========
+
+Termite loggers, like Ruby loggers, allow you to set the logger's level.  All events below that
+level will be silently discarded, and will also not be sent to non-syslog loggers.  You can change
+the level with "logger.level = Logger::WARN" and similar.
+
+By default, Termite will log events of all severities to standard output, and events of at least
+severity :error to standard error.  You can set .stdout_level and .stderr_level just like setting
+.level above.  Level takes precedence over the other two and stderr_level takes precedence over
+stdout_level.
+
+Non-Syslog Logging
+==================
+
+If a filename or handle is specified in the constructor, Termite will instantiate a Ruby Logger
+with the same parameters and mirror all events to it.
+
+You can pass in objects with an :add method to a Termite logger's "add_extra_logger" method, and
+from then on all events will be mirrored to that object.  This can be useful for chaining loggers
+if you need to.  Events below the Termite logger's level (see above) won't be mirrored.
+
+Translating to SysLog
+=====================
+
+When writing to SysLog, Termite translates Ruby Logger severities into SysLog severities.  By
+default, this is the mapping:
+
+Logger   => SysLog
+:unknown => :alert
+:fatal   => :crit
+:error   => :err
+:warn    => :warning
+:info    => :info
+:debug   => :debug
+
+Configuring with an Ecology
+===========================
+
+Termite supports a standard Ecology file.  By default, it will look at the location of the current
+executable ($0) with extension .ecology.  So "bob.rb" would have "bob.ecology" next to it.
+
+An Ecology is a JSON file of roughly this structure:
+
+{
+  "application": "MyApp",
+  "logging": {
+    "default_component": "SplodgingLib",
+    "extra_json_fields": {
+      "app_group": "SuperSpiffyGroup",
+      "precedence": 7
+    },
+    "console_print": "off",
+    "filename": "/tmp/bobo.txt",
+    "shift_age": 10,
+    "shift_size": 1024000,
+    "stderr_level": "fatal"
+  }
+}
+
+Absolutely every part of it is optional, including the presence of the file at all.
+
+You can override the application name, as shown above.  Other than the application name,
+all Termite-specific parameters are under the "logging" field, as above.
+
+The default_component is what application component is given for an add() call by default.
+If set, it can be removed with ":component => nil" for a given add() call.
+
+Extra JSON fields are added to the JSON data of every add() call.
+
+Console_print can be set to "off" (or "no" or "0") to turn off Termite printing to stderr
+and stdout by default at different log levels.
+
+Filename, shift_age and shift_size are the same as Ruby Logger's normal initialize
+parameters.  The first is the filename to log to, the second is how many total log files
+to keep, and the third is how large each log file can grow.  Or the second can be set to
+a value like "daily" or "monthly", and then the third is irrelevant.
+
+You can also set level, stdout_level and stderr_level explained above.  We allow numerical
+(syslog) values, or standard names of Ruby Logger severities.
+
+Releasing within Ooyala
+=======================
+
+Ooyalans, to release Termite to gems.sv2, use the following:
+
+  gem build
+  rake _0.8.7_ -f ../ooyala_gems.rake gem:push termite-0.0.1.gem
+
+Change the version to the actual version you'd like to push.

data/Rakefile

@@ -0,0 +1,20 @@
+require "bundler"
+require "rake/testtask"
+
+require File.join(File.dirname(__FILE__), "lib", "termite", "version")
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = Dir.glob("test/**/*test.rb")
+  t.verbose = true
+end
+
+desc 'Builds the gem'
+task :build do
+  sh "gem build termite.gemspec"
+end
+
+desc 'Builds and installs the gem'
+task :install => :build do
+  sh "gem install termite-#{Termite::VERSION}"
+end

data/TODO

@@ -0,0 +1,3 @@
+Ecology configuration:
+  * Extra loggers from Ecology
+  * Transport protocol from Ecology

data/lib/termite/version.rb

@@ -0,0 +1,3 @@
+module Termite
+  VERSION = "0.0.10"
+end

data/lib/termite.rb

@@ -0,0 +1,259 @@
+require "rubygems"
+require "termite/version"
+
+require "ecology"
+require "multi_json"
+
+require "thread"
+require "syslog"
+require "logger"
+require "socket"
+
+module Termite
+  class Logger
+    ##
+    # Maps Logger severities to syslog(3) severities.
+
+    LOGGER_MAP = {
+      :unknown => :alert,
+      :fatal   => :crit,
+      :error   => :err,
+      :warn    => :warning,
+      :info    => :info,
+      :debug   => :debug,
+    }
+
+    ##
+    # Maps Ruby Logger log levels to their values so we can silence.
+
+    LOGGER_LEVEL_MAP = {}
+
+    LOGGER_MAP.each_key do |key|
+      LOGGER_LEVEL_MAP[key] = ::Logger.const_get key.to_s.upcase
+    end
+
+    ##
+    # Maps Logger numerical log level values to syslog log levels.
+
+    LEVEL_LOGGER_MAP = {}
+
+    LOGGER_LEVEL_MAP.invert.each do |level, severity|
+      LEVEL_LOGGER_MAP[level] = LOGGER_MAP[severity]
+    end
+
+    SYSLOG_SEVERITY_MAP = {}
+
+    LOGGER_MAP.values.each do |syslog_severity|
+      SYSLOG_SEVERITY_MAP[syslog_severity] = ::Syslog.const_get("LOG_" + syslog_severity.to_s.upcase)
+    end
+
+    ##
+    # Builds a methods for level +meth+.
+
+    def self.make_methods(meth)
+      eval <<-EOM, nil, __FILE__, __LINE__ + 1
+        def #{meth}(message = nil, data = {}, options = {}, &block)
+          return true if #{LOGGER_LEVEL_MAP[meth]} < @level
+          add(::Logger::#{meth.to_s.upcase}, message, data, options, &block)
+        end
+
+        def #{meth}?
+          @level <= ::Logger::#{meth.to_s.upcase}
+        end
+      EOM
+    end
+
+    LOGGER_MAP.each_key do |level|
+      make_methods level
+    end
+
+    ##
+    # Log level for Logger compatibility.
+
+    attr_accessor :level
+    attr_reader :stdout_level
+    attr_reader :stderr_level
+    attr_reader :file_logger
+
+    def initialize(logdev = nil, shift_age = 0, shift_size = 1048576, options = {})
+      options = logdev if(logdev.is_a?(Hash))
+
+      Ecology.read
+
+      read_ecology_data
+      @log_filename ||= logdev
+
+      @file_logger = ::Logger.new(@log_filename, @shift_age || shift_age, @shift_size || shift_size) if @log_filename
+      @extra_loggers << @file_logger if @file_logger
+
+      # For UDP socket
+      @server_addr = options[:address] || "0.0.0.0"
+      @server_port = options[:port] ? options[:port].to_i : 514
+
+      @@sockets ||= {}
+      key = "#{@server_addr}:#{@server_port}"
+      @@sockets[key] ||= UDPSocket.new
+      @socket = @@sockets[key]
+    end
+
+    private
+
+    def string_to_severity(str)
+      orig_string = str
+      str = str.strip.downcase
+      return str.to_i if str =~ /\d+/
+      ret = LOGGER_LEVEL_MAP[str.to_sym]
+      raise "Unknown logger severity #{orig_string}" unless ret
+      ret
+    end
+
+    def read_ecology_data
+      @application = Ecology.application
+
+      @extra_loggers = []
+
+      # @console_print defaults to "yes", but can be nil if "no", "off" or "0" is specified
+      @console_print = Ecology.property("logging::console_print") || "yes"
+      @console_print = nil if ["no", "off", "0"].include?(@console_print)
+
+      @log_filename = Ecology.property("logging::filename", :as => :path)
+      @shift_age = Ecology.property("logging::shift_age")
+      @shift_size = Ecology.property("logging::shift_size")
+      @default_component = Ecology.property("logging::default_component")
+      @level = Ecology.property("logging::level")
+      @level = string_to_severity(@level) if @level
+      @stderr_level = Ecology.property("logging::stderr_level")
+      @stderr_level = string_to_severity(@stderr_level) if @stderr_level
+      @stdout_level = Ecology.property("logging::stdout_level")
+      @stdout_level = string_to_severity(@stdout_level) if @stdout_level
+
+      @default_fields = Ecology.property("logging::extra_json_fields") || {}
+
+      @level ||= ::Logger::DEBUG
+      @stdout_level ||= ::Logger::INFO
+      @stderr_level ||= ::Logger::ERROR
+    end
+
+    public
+
+    def add_logger(logger)
+      @extra_loggers << logger
+    end
+
+    def socket
+      @socket
+    end
+
+    def raw_add(severity, message = nil, data = nil, options = {}, &block)
+      raw_message = message
+      # Severity is a numerical severity using Ruby Logger's scale
+      severity ||= ::Logger::UNKNOWN
+      return true if severity < @level
+
+      application = options[:application] || @application
+
+      component ||= @default_component
+      component = options[:component] if options.has_key?(:component)
+      if component
+        application += ":" + component
+      end
+
+      data ||= {}
+      if data.is_a?(Hash)
+        data = @default_fields.merge(data)
+        data = MultiJson.encode(data)
+      elsif data.is_a?(String)
+        # Can't merge a JSON string with default data
+        raise "Can't merge a JSON string with extra fields!" unless @default_fields.empty?
+      else
+        raise "Unknown data object passed as JSON!"
+      end
+
+      tid = Ecology.thread_id(Thread.current)
+      time = Time.now
+      day = time.strftime("%b %d").sub(/0(\d)/, ' \\1')
+      time_of_day = time.strftime("%T")
+      hostname = Socket.gethostname
+      tag = Syslog::LOG_LOCAL6 + SYSLOG_SEVERITY_MAP[LEVEL_LOGGER_MAP[severity]]
+
+      syslog_string = "<#{tag}>#{day} #{time_of_day} #{hostname} #{application} [#{Process.pid}]: [#{tid}] "
+      full_message = clean(message || block.call)
+
+      # ruby_severity is the Ruby Logger severity as a symbol
+      ruby_severity = LOGGER_LEVEL_MAP.invert[severity]
+
+      full_message.split("\n").each do |line|
+        message = syslog_string + "#{line} #{data}"
+
+        begin
+          @socket.send(message, 0, @server_addr, @server_port)
+        rescue Exception
+          # Didn't work.  Try built-in Ruby syslog
+          require "syslog"
+          Syslog.open(application, Syslog::LOG_PID | Syslog::LOG_CONS) do |s|
+            s.error("UDP syslog failed!  Falling back to libc syslog!") rescue nil
+            s.send(LEVEL_LOGGER_MAP[severity], "#{line} #{data}") rescue nil
+          end
+        end
+      end
+
+      if @console_print && severity >= @stderr_level
+        STDERR.puts raw_message
+      elsif @console_print && severity >= @stdout_level
+        STDOUT.puts raw_message
+      end
+
+      @extra_loggers.each do |logger|
+        logger.send(ruby_severity, raw_message) rescue nil
+      end
+
+      true
+    end
+
+    def add(*args)
+      begin
+        raw_add(*args)
+      rescue Exception => e
+        STDERR.puts("Couldn't log via Termite!  Failing!  Arguments:")
+        STDERR.puts(args.inspect)
+        STDERR.puts("Exception: #{e.message}")
+        STDERR.puts("Backtrace: #{e.backtrace.inspect}")
+      end
+    end
+
+    alias :log :add
+
+    # This isn't perfect.  "Real" Ruby loggers use << to mean
+    # "write directly to the underlying store without adding
+    # headers or other cruft".  That's meaningful for file
+    # loggers, but not for syslog.
+    def << (message)
+      add(::Logger::INFO, message)
+    end
+
+    ##
+    # Allows messages of a particular log level to be ignored temporarily.
+    #
+    # Can you say "Broken Windows"?
+
+    def silence(temporary_level = ::Logger::ERROR)
+      old_logger_level = @level
+      @level = temporary_level
+      yield
+    ensure
+      @level = old_logger_level
+    end
+
+    private
+
+    ##
+    # Clean up messages so they're nice and pretty.
+
+    def clean(message)
+      message = message.to_s.dup
+      message.strip!
+      message.gsub!(/\e\[[^m]*m/, '') # remove useless ansi color codes
+      return message
+    end
+  end
+end

data/termite.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+require "termite/version"
+
+Gem::Specification.new do |s|
+  s.name        = "termite"
+  s.version     = Termite::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Noah Gibbs"]
+  s.email       = ["noah@ooyala.com"]
+  s.homepage    = "http://www.ooyala.com"
+  s.summary     = %q{Ruby logging based on Syslog}
+  s.description = <<EOS
+Termite wraps syslog with a format for extra data, and for
+what you wish it would send automatically.
+EOS
+
+  s.rubyforge_project = "termite"
+
+  ignores = File.readlines(".gitignore").grep(/\S+/).map {|pattern| pattern.chomp }
+  dotfiles = Dir[".*"]
+  s.files = Dir["**/*"].reject {|f| File.directory?(f) || ignores.any? {|i| File.fnmatch(i, f) } } + dotfiles
+  s.test_files = s.files.grep(/^test\//)
+
+  s.require_paths = ["lib"]
+
+  s.add_dependency "multi_json"
+  s.add_dependency "ecology", "~>0.0.6"
+
+  s.add_development_dependency "bundler", "~> 1.0.10"
+  s.add_development_dependency "scope", "~> 0.2.1"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "rake"
+end

data/test/ecology_log_test.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+
+class EcologyLogTest < Scope::TestCase
+  context "with a custom ecology" do
+    setup do
+      Ecology.reset
+
+      set_up_ecology <<ECOLOGY_CONTENTS
+{
+  "application": "MyApp",
+  "logging": {
+    "default_component": "SplodgingLib",
+    "extra_json_fields": {
+      "app_group": "SuperSpiffyGroup",
+      "precedence": 7
+    },
+    "console_print": "off",
+    "filename": "/tmp/bobo.txt",
+    "shift_age": 10,
+    "shift_size": 1024000
+  }
+}
+ECOLOGY_CONTENTS
+    end
+
+    context "with a default termite logger" do
+      setup do
+        @logger = Termite::Logger.new
+      end
+
+      should "send back extra JSON data and a default component when specified" do
+        expect_add(@logger.socket, 2, 'oh no! {"app_group":"SuperSpiffyGroup","precedence":7}', :application => "MyApp:SplodgingLib")
+        @logger.fatal("oh no!")
+      end
+
+      should "allow overriding the default component" do
+        expect_add(@logger.socket, 2, 'oh no! {"app_group":"SuperSpiffyGroup","precedence":7}', :application => "MyApp:SpliyingLib")
+        @logger.fatal("oh no!", {}, :component => "SpliyingLib")
+      end
+
+      should "allow overriding the default component with nothing" do
+        expect_add(@logger.socket, 2, 'oh no! {"app_group":"SuperSpiffyGroup","precedence":7}', :application => "MyApp")
+        @logger.fatal("oh no!", {}, :component => nil)
+      end
+    end
+
+    should "pass initialize parameters to Ruby Logger" do
+      log_mock = mock("Ruby Logger")
+      ::Logger.expects(:new).with("/tmp/bobo.txt", 10, 1024000).returns(log_mock)
+      Termite::Logger.new
+    end
+
+    should "override parameters passed to Termite Logger" do
+      log_mock = mock("Ruby Logger")
+      ::Logger.expects(:new).with("/tmp/bobo.txt", 10, 1024000).returns(log_mock)
+      Termite::Logger.new("/var/lib/sam.log", "daily")
+    end
+  end
+end

data/test/extra_logger_test.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+
+class TermiteExtraLoggerTest < Scope::TestCase
+  context "with termite" do
+    setup do
+      $0 = "MyApp"
+      Ecology.reset
+    end
+
+    context "and two extra loggers added" do
+      setup do
+        @logger = Termite::Logger.new("/tmp/test_log_output.txt")  # Test with output file
+        @logger.level = Logger::DEBUG
+        @logger.socket.expects(:send)
+        @mock_logger_1 = mock()
+        @logger.add_logger(@mock_logger_1)
+        @logger.add_logger(@mock_logger_2)
+      end
+
+      should "correctly send logs to Syslog" do
+        @mock_logger_1.expects(:fatal)
+        @mock_logger_2.expects(:fatal)
+        @logger.add(Logger::FATAL, "foo!", {})
+      end
+    end
+  end
+end

data/test/log_locally.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "termite"
+
+logger = Termite::Logger.new
+logger.fatal("Test logging from log_locally.rb!")

data/test/rescue_test.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+require "syslog"
+
+class RescueTest < Scope::TestCase
+  context "with termite" do
+    setup do
+      Ecology.reset
+      @logger = Termite::Logger.new("/tmp/termite_test.log")
+    end
+
+    should "continue even if all loggers raise errors" do
+      # First, UDP will raise an error
+      @logger.socket.expects(:send).raises(StandardError, "You suck!")
+
+      # Termite should fall back to trying Ruby Syslog...
+      syslog_mock = mock("Syslog connection")
+      Syslog.expects(:open).yields(syslog_mock)
+      syslog_mock.expects(:error).with("UDP syslog failed!  Falling back to libc syslog!")
+      syslog_mock.expects(:crit).raises(StandardError, "You suck even more than that!")
+
+      # And it should still try to write to a file logger
+      @logger.file_logger.expects(:fatal).raises(StandardError, "You suck lots!")
+
+      extra_logger = mock("Additional logger")
+      @logger.add_logger(extra_logger)
+      # And it should try to write to any extra loggers
+      extra_logger.expects(:fatal).raises(StandardError, "You suck constantly!")
+
+      # And yet, nothing should be raised to the outside world
+      begin
+        @logger.fatal("Woe is me!")
+        assert true, "Nothing was raised!  Yay!"
+      rescue Exception
+        flunk "Logging an event raised an assertion outside the logger!"        
+      end
+    end
+
+    should "continue even if internal logic gives an error" do
+      #Time.expects(:now).raises(Exception.new "You suck!")
+      Ecology.expects(:thread_id).raises(Exception.new "Ecology thread_id dies!")
+      begin
+        @logger.fatal("Woe is me!")
+        assert true, "Nothing was raised!  Yay!"
+      rescue Exception
+        flunk "Logging an event raised an assertion outside the logger!"
+      end
+    end
+  end
+end

data/test/stderr_log_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+
+class EcologyLogTest < Scope::TestCase
+  context "with a custom ecology" do
+    setup do
+      Ecology.reset
+
+      set_up_ecology <<ECOLOGY_CONTENTS
+{
+  "application": "MyApp",
+  "logging": {
+    "stdout_level": "warn",
+    "stderr_level": "fatal"
+  }
+}
+ECOLOGY_CONTENTS
+    end
+
+    context "with a default termite logger" do
+      setup do
+        @logger = Termite::Logger.new
+      end
+
+      should "log fatal errors to STDERR" do
+        expect_console_add(STDERR, 2, 'oh no!', :application => "MyApp", :method => :puts, :extra_args => [])
+        STDOUT.expects(:puts).never
+        @logger.fatal("oh no!")
+      end
+
+      should "log warnings to STDOUT" do
+        expect_console_add(STDOUT, 4, 'oh no!', :application => "MyApp", :method => :puts, :extra_args => [])
+        STDERR.expects(:puts).never
+        @logger.warn("oh no!")
+      end
+
+    end
+  end
+end

data/test/termite_logger_test.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+require "syslog"
+
+class TermiteLoggerTest < Scope::TestCase
+  context "with termite ecology" do
+    setup do
+      Ecology.reset
+
+      set_up_ecology <<ECOLOGY_TEXT
+{
+  "application": "foo_app"
+}
+ECOLOGY_TEXT
+    end
+
+    context "and fully permissive logging levels set" do
+      setup do
+        @logger = Termite::Logger.new("/tmp/test_log_output.txt")  # Test with output file
+        @logger.level = Logger::DEBUG
+      end
+
+      should "correctly send logs to Syslog" do
+        expect_add(@logger.socket, 2, "foo! {}")
+        @logger.add(Logger::FATAL, "foo!", {})
+      end
+
+      should "correctly alias log to add" do
+        expect_add(@logger.socket, 2, "foo! {}")
+        @logger.log(Logger::FATAL, "foo!", {})
+      end
+
+      should "treat << as add-with-info" do
+        expect_add(@logger.socket, 6, "foo! {}")
+        @logger << "foo!"
+      end
+
+      should "correctly send an alert to Syslog" do
+        expect_add(@logger.socket, 1, "foo! {}")
+        @logger.add(Logger::UNKNOWN, "foo!", {})
+      end
+
+      should "correctly send a critical event to Syslog" do
+        expect_add(@logger.socket, 2, "foo! {}")
+        @logger.fatal("foo!")
+      end
+
+      should "correctly send an error event to Syslog" do
+        expect_add(@logger.socket, 3, "foo! {}")
+        @logger.error("foo!")
+      end
+
+      should "correctly send a warning event to Syslog" do
+        expect_add(@logger.socket, 4, "foo! {}")
+        @logger.warn("foo!")
+      end
+
+      should "correctly send an info event to Syslog" do
+        expect_add(@logger.socket, 6, "foo! {}")
+        @logger.info("foo!")
+      end
+
+      should "correctly send a debug event to Syslog" do
+        expect_add(@logger.socket, 7, "foo! {}")
+        @logger.debug("foo!")
+      end
+    end
+
+    context "and default setup for components" do
+      setup do
+        @logger = Termite::Logger.new("/tmp/test_log_output.txt")  # Test with output file
+      end
+
+      should "allow overriding application name" do
+        expect_add(@logger.socket, 2, "foo! {}", :application => "bar_app")
+        @logger.fatal("foo!", {}, :application => "bar_app")
+      end
+
+      should "allow setting a component" do
+        expect_add(@logger.socket, 2, "foo! {}", :application => "foo_app:whatcomponent")
+        @logger.fatal("foo!", {}, :component => "whatcomponent")
+      end
+    end
+
+  end
+end

data/test/termite_subclass_test.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), "test_helper.rb")
+
+class SubLogger < Termite::Logger
+end
+
+class TermiteSubclassTest < Scope::TestCase
+  context "with subclassed termite" do
+    setup do
+      Ecology.reset
+
+      set_up_ecology <<ECOLOGY_TEXT
+{
+  "application": "foo_app"
+}
+ECOLOGY_TEXT
+    end
+
+    context "and only default logging levels set" do
+      setup do
+        @logger = SubLogger.new
+      end
+
+      should "correctly send logs to Syslog" do
+        @logger.socket.expects(:send)
+        @logger.add(Logger::FATAL, "foo!", {})
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,51 @@
+require "rubygems"
+require "bundler"
+Bundler.require(:default, :development)
+require "minitest/autorun"
+
+# For testing Termite itself, use the local version *first*.
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require "termite"
+
+class Scope::TestCase
+  def set_up_ecology(file_contents, filename = "some.ecology")
+    ENV["ECOLOGY_SPEC"] = filename
+    File.expects(:exist?).with(filename).returns(true)
+    File.expects(:read).with(filename).returns(file_contents)
+  end
+
+  def initialize_environment
+    unless @initialized_test_env
+      Time.stubs(:now).returns(Time.at(1315433360))
+      Socket.stubs(:gethostname).returns("samplehost")
+      Process.stubs(:pid).returns("1234")
+      Ecology.stubs(:thread_id).returns("main")
+
+      @initialized_test_env = true
+    end
+  end
+
+  # This adds the Mocha expectation for this call.  Technically it also
+  # returns the expectation, so you could modify it later if you wanted.
+  def expect_add(socket, severity_num, message, options = {})
+    initialize_environment
+
+    app = options[:application] || "foo_app"
+    string = "<#{Syslog::LOG_LOCAL6 + severity_num}>Sep  7 15:09:20 samplehost #{app} [1234]: [main] #{message}"
+
+    options[:method] ||= :send
+    options[:extra_args] ||= [0, "0.0.0.0", 514]
+    socket.expects(options[:method]).with(string, *options[:extra_args])
+  end
+
+  def expect_console_add(socket, severity_num, message, options = {})
+    initialize_environment
+
+    app = options[:application] || "foo_app"
+
+    options[:method] ||= :send
+    options[:extra_args] ||= [0, "0.0.0.0", 514]
+    socket.expects(options[:method]).with(message, *options[:extra_args])
+  end
+end

metadata

@@ -1,45 +1,147 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: termite
-version: !ruby/object:Gem::Version
-  version: 0.0.2
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.0.10
 platform: ruby
-authors:
-- Caleb Spare
+authors: 
+- Noah Gibbs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-23 00:00:00.000000000Z
-dependencies: []
-description: termite
-email:
-- caleb@ooyala.com
+
+date: 2011-09-30 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: multi_json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ecology
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.0.6
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.10
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: scope
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.2.1
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: |
+  Termite wraps syslog with a format for extra data, and for
+  what you wish it would send automatically.
+
+email: 
+- noah@ooyala.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files: []
-homepage: ''
+
+files: 
+- Gemfile
+- Gemfile.lock
+- lib/termite/version.rb
+- lib/termite.rb
+- LICENSE
+- Rakefile
+- README.md
+- termite.gemspec
+- test/ecology_log_test.rb
+- test/extra_logger_test.rb
+- test/log_locally.rb
+- test/rescue_test.rb
+- test/stderr_log_test.rb
+- test/termite_logger_test.rb
+- test/termite_subclass_test.rb
+- test/test_helper.rb
+- TODO
+- .gitignore
+homepage: http://www.ooyala.com
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      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
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
 requirements: []
+
 rubyforge_project: termite
-rubygems_version: 1.8.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: termite
-test_files: []
+summary: Ruby logging based on Syslog
+test_files: 
+- test/ecology_log_test.rb
+- test/extra_logger_test.rb
+- test/log_locally.rb
+- test/rescue_test.rb
+- test/stderr_log_test.rb
+- test/termite_logger_test.rb
+- test/termite_subclass_test.rb
+- test/test_helper.rb