clogger 0.9.0 → 1.0.0

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v0.9.0.GIT
+DEF_VER=v1.0.0.GIT
 
 LF='
 '

data/README

@@ -73,9 +73,10 @@ that receives a "<<" method:
   (including response body iteration).  PRECISION defaults to 3
   (milliseconds) if not specified but may be specified anywhere from
   0(seconds) to 6(microseconds).
-* $time_local, $time_local{FORMAT} - current local time, FORMAT defaults to
-  "%d/%b/%Y:%H:%M:%S %z" but accepts any strftime(3)-compatible format
-* $time_utc, $time_utc{FORMAT} - like $time_local, except with UTC
+* $time_iso8601 - current local time in ISO 8601 format,
+  e.g. "1970-01-01T00:00:00+00:00"
+* $time_local - current local time in Apache log format,
+  e.g. "01/Jan/1970:00:00:00 +0000"
 * $usec - current time in seconds.microseconds since the Epoch
 * $msec - current time in seconds.milliseconds since the Epoch
 * $body_bytes_sent - bytes in the response body (Apache: %B)
@@ -110,7 +111,7 @@ development.  Patches should always be sent inline
 
 == CONTACT
 
-All feedback (bug reports, user/development dicussion, patches, pull
+All feedback (bug reports, user/development discussion, patches, pull
 requests) go to the mailing list.
 
 * mailto:clogger@librelist.com

data/ext/clogger_ext/clogger.c

@@ -17,6 +17,7 @@
 #  define _POSIX_C_SOURCE 200112L
 #endif
 #include <time.h>
+#include <stdlib.h>
 #include "ruby_1_9_compat.h"
 #include "broken_system_compat.h"
 #include "blocking_helpers.h"
@@ -89,7 +90,10 @@ enum clogger_special {
 	CL_SP_response_length,
 	CL_SP_ip,
 	CL_SP_pid,
-	CL_SP_request_uri
+	CL_SP_request_uri,
+	CL_SP_time_iso8601,
+	CL_SP_time_local,
+	CL_SP_time_utc
 };
 
 struct clogger {
@@ -443,6 +447,75 @@ static void append_request_length(struct clogger *c)
 	}
 }
 
+static long local_gmtoffset(struct tm *tm)
+{
+	time_t t = time(NULL);
+
+	tzset();
+	localtime_r(&t, tm);
+#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
+	return tm->tm_gmtoff / 60;
+#else
+	return -(tm->tm_isdst ? timezone - 3600 : timezone) / 60;
+#endif
+}
+
+static void append_time_iso8601(struct clogger *c)
+{
+	char buf[sizeof("1970-01-01T00:00:00+00:00")];
+	struct tm tm;
+	int nr;
+	long gmtoff = local_gmtoffset(&tm);
+
+	nr = snprintf(buf, sizeof(buf),
+	              "%4d-%02d-%02dT%02d:%02d:%02d%c%02d:%02d",
+	              tm.tm_year + 1900, tm.tm_mon + 1,
+	              tm.tm_mday, tm.tm_hour,
+	              tm.tm_min, tm.tm_sec,
+	              gmtoff < 0 ? '-' : '+',
+	              abs(gmtoff / 60), abs(gmtoff % 60));
+	assert(nr == (sizeof(buf) - 1) && "snprintf fail");
+	rb_str_buf_cat(c->log_buf, buf, sizeof(buf) - 1);
+}
+
+static const char months[] = "Jan\0Feb\0Mar\0Apr\0May\0Jun\0"
+                             "Jul\0Aug\0Sep\0Oct\0Nov\0Dec";
+
+static void append_time_local(struct clogger *c)
+{
+	char buf[sizeof("01/Jan/1970:00:00:00 +0000")];
+	struct tm tm;
+	int nr;
+	long gmtoff = local_gmtoffset(&tm);
+
+	nr = snprintf(buf, sizeof(buf),
+	              "%02d/%s/%d:%02d:%02d:%02d %c%02d%02d",
+	              tm.tm_mday, months + (tm.tm_mon * sizeof("Jan")),
+	              tm.tm_year + 1900, tm.tm_hour,
+	              tm.tm_min, tm.tm_sec,
+	              gmtoff < 0 ? '-' : '+',
+	              abs(gmtoff / 60), abs(gmtoff % 60));
+	assert(nr == (sizeof(buf) - 1) && "snprintf fail");
+	rb_str_buf_cat(c->log_buf, buf, sizeof(buf) - 1);
+}
+
+static void append_time_utc(struct clogger *c)
+{
+	char buf[sizeof("01/Jan/1970:00:00:00 +0000")];
+	struct tm tm;
+	int nr;
+	time_t t = time(NULL);
+
+	gmtime_r(&t, &tm);
+	nr = snprintf(buf, sizeof(buf),
+	              "%02d/%s/%d:%02d:%02d:%02d +0000",
+	              tm.tm_mday, months + (tm.tm_mon * sizeof("Jan")),
+	              tm.tm_year + 1900, tm.tm_hour,
+	              tm.tm_min, tm.tm_sec);
+	assert(nr == (sizeof(buf) - 1) && "snprintf fail");
+	rb_str_buf_cat(c->log_buf, buf, sizeof(buf) - 1);
+}
+
 static void
 append_time(struct clogger *c, enum clogger_opcode op, VALUE fmt, VALUE buf)
 {
@@ -547,6 +620,15 @@ static void special_var(struct clogger *c, enum clogger_special var)
                 break;
 	case CL_SP_request_uri:
 		append_request_uri(c);
+		break;
+	case CL_SP_time_iso8601:
+		append_time_iso8601(c);
+		break;
+	case CL_SP_time_local:
+		append_time_local(c);
+		break;
+	case CL_SP_time_utc:
+		append_time_utc(c);
 	}
 }
 
@@ -640,8 +722,8 @@ static void init_logger(struct clogger *c, VALUE path)
  *
  * Creates a new Clogger object that wraps +app+.  +:logger+ may
  * be any object that responds to the "<<" method with a string argument.
- * If +:logger:+ is a string, it will be treated as a path to a
- * File that will be opened in append mode.
+ * Instead of +:logger+, +:path+ may be specified to be a :path of a File
+ * that will be opened in append mode.
  */
 static VALUE clogger_init(int argc, VALUE *argv, VALUE self)
 {

data/ext/clogger_ext/extconf.rb

@@ -24,7 +24,6 @@ begin
   have_func('rb_str_set_len', 'ruby.h')
   have_func('rb_thread_blocking_region', 'ruby.h')
   have_func('rb_thread_io_blocking_region', 'ruby.h')
-  dir_config('clogger_ext')
   create_makefile('clogger_ext')
 rescue Object => err
   warn "E: #{err.inspect}"

data/lib/clogger.rb

@@ -19,8 +19,6 @@ class Clogger
   # support nginx variables that are less customizable than our own
   ALIASES = {
     '$request_time' => '$request_time{3}',
-    '$time_local' => '$time_local{%d/%b/%Y:%H:%M:%S %z}',
-    '$time_utc' => '$time_utc{%d/%b/%Y:%H:%M:%S %z}',
     '$msec' => '$time{3}',
     '$usec' => '$time{6}',
     '$http_content_length' => '$content_length',
@@ -35,7 +33,10 @@ class Clogger
     :response_length => 4, # like body_bytes_sent, except "-" instead of "0"
     :ip => 5, # HTTP_X_FORWARDED_FOR || REMOTE_ADDR || -
     :pid => 6, # getpid()
-    :request_uri => 7
+    :request_uri => 7,
+    :time_iso8601 => 8,
+    :time_local => 9,
+    :time_utc => 10,
   }
 
 private
@@ -55,6 +56,7 @@ private
                         \w*))?([^$]*)/x
 
   def compile_format(str, opt = {})
+    str = Clogger::Format.const_get(str) if Symbol === str
     longest_day = Time.at(26265600) # "Saturday, November 01, 1970 00:00:00"
     rv = []
     opt ||= {}

data/lib/clogger/pure.rb

@@ -135,6 +135,20 @@ private
       env['REMOTE_ADDR'] || '-'
     when :pid
       $$.to_s
+    when :time_iso8601
+      Time.now.iso8601
+    when :time_local
+      t = Time.now
+      off = t.utc_offset
+      sign = off < 0 ? '-' : '+'
+      sprintf("%02d/%s/%d:%02d:%02d:%02d #{sign}%02d%02d",
+              t.mday, Time::RFC2822_MONTH_NAME[t.mon - 1],
+              t.year, t.hour, t.min, t.sec, *(off.abs / 60).divmod(60))
+    when :time_utc
+      t = Time.now.utc
+      sprintf("%02d/%s/%d:%02d:%02d:%02d +0000",
+              t.mday, Time::RFC2822_MONTH_NAME[t.mon - 1],
+              t.year, t.hour, t.min, t.sec)
     else
       raise "EDOOFUS #{special_nr}"
     end

data/test/test_clogger.rb

@@ -1,6 +1,7 @@
 # -*- encoding: binary -*-
 $stderr.sync = $stdout.sync = true
 require "test/unit"
+require "time"
 require "date"
 require "stringio"
 require "tempfile"
@@ -17,6 +18,8 @@ class TestClogger < Test::Unit::TestCase
   include Clogger::Format
 
   def setup
+    @tz = ENV["TZ"]
+    @nginx_fmt = "%d/%b/%Y:%H:%M:%S %z"
     @req = {
       "REQUEST_METHOD" => "GET",
       "HTTP_VERSION" => "HTTP/1.0",
@@ -29,6 +32,10 @@ class TestClogger < Test::Unit::TestCase
     }
   end
 
+  def teardown
+    ENV["TZ"] = @tz
+  end
+
   def test_init_basic
     Clogger.new(lambda { |env| [ 0, {}, [] ] })
   end
@@ -37,6 +44,11 @@ class TestClogger < Test::Unit::TestCase
     assert_raise(ArgumentError) { Clogger.new }
   end
 
+  def test_clogger_sym_format
+    app = lambda { |env| [ 0, {}, [] ] }
+    tmp = Clogger.new app, :format => :Rack_1_0, :logger => $stderr
+  end
+
   def test_init_stderr
     cl = Clogger.new(lambda { |env| [ 0, {}, [] ] }, :logger => $stderr)
     assert_kind_of(Integer, cl.fileno)
@@ -156,13 +168,12 @@ class TestClogger < Test::Unit::TestCase
         '$env{rack.url_scheme}' \
         "\n")
     }
-    longest_day = Time.at(26265600).strftime('%d/%b/%Y:%H:%M:%S %z')
     expect = [
       [ Clogger::OP_REQUEST, "REMOTE_ADDR" ],
       [ Clogger::OP_LITERAL, " - " ],
       [ Clogger::OP_REQUEST, "REMOTE_USER" ],
       [ Clogger::OP_LITERAL, " [" ],
-      [ Clogger::OP_TIME_LOCAL, '%d/%b/%Y:%H:%M:%S %z', longest_day ],
+      [ Clogger::OP_SPECIAL, Clogger::SPECIAL_VARS[:time_local] ],
       [ Clogger::OP_LITERAL, "] \"" ],
       [ Clogger::OP_SPECIAL, Clogger::SPECIAL_VARS[:request] ],
       [ Clogger::OP_LITERAL, "\" "],
@@ -698,6 +709,65 @@ class TestClogger < Test::Unit::TestCase
     assert %r!\A\d+/\w+/\d{4}:\d\d:\d\d:\d\d \+0000\n\z! =~ s[0], s.inspect
   end
 
+  def test_time_iso8601
+    s = []
+    app = lambda { |env| [200, [], [] ] }
+    cl = Clogger.new(app, :logger => s, :format => "$time_iso8601")
+    status, headers, body = cl.call(@req)
+    t = Time.parse(s[0])
+    assert_equal t.iso8601, s[0].strip
+  end
+
+  def test_time_iso8601_pst8pdt
+    ENV["TZ"] = "PST8PDT"
+    s = []
+    app = lambda { |env| [200, [], [] ] }
+    cl = Clogger.new(app, :logger => s, :format => "$time_iso8601")
+    status, headers, body = cl.call(@req)
+    t = Time.parse(s[0])
+    assert_equal t.iso8601, s[0].strip
+  end
+
+  def test_time_iso8601_utc
+    ENV["TZ"] = "UTC"
+    s = []
+    app = lambda { |env| [200, [], [] ] }
+    cl = Clogger.new(app, :logger => s, :format => "$time_iso8601")
+    status, headers, body = cl.call(@req)
+    t = Time.parse(s[0])
+    assert_equal t.iso8601, s[0].strip
+  end
+
+  def test_time_local
+    s = []
+    app = lambda { |env| [200, [], [] ] }
+    cl = Clogger.new(app, :logger => s, :format => "$time_local")
+    status, headers, body = cl.call(@req)
+    t = DateTime.strptime(s[0].strip, @nginx_fmt)
+    assert_equal t.strftime(@nginx_fmt), s[0].strip
+  end
+
+  def test_time_local_pst8pdt
+    orig = ENV["TZ"]
+    ENV["TZ"] = "PST8PDT"
+    s = []
+    app = lambda { |env| [200, [], [] ] }
+    cl = Clogger.new(app, :logger => s, :format => "$time_local")
+    status, headers, body = cl.call(@req)
+    t = DateTime.strptime(s[0].strip, @nginx_fmt)
+    assert_equal t.strftime(@nginx_fmt), s[0].strip
+  end
+
+  def test_time_local_utc
+    ENV["TZ"] = "UTC"
+    s = []
+    app = lambda { |env| [200, [], [] ] }
+    cl = Clogger.new(app, :logger => s, :format => "$time_local")
+    status, headers, body = cl.call(@req)
+    t = DateTime.strptime(s[0].strip, @nginx_fmt)
+    assert_equal t.strftime(@nginx_fmt), s[0].strip
+  end
+
   def test_method_missing
     s = []
     body = []

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: clogger
 version: !ruby/object:Gem::Version 
-  hash: 59
+  hash: 23
   prerelease: 
   segments: 
+  - 1
   - 0
-  - 9
   - 0
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors: 
 - cloggers
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-15 00:00:00 +00:00
-default_executable: 
+date: 2011-04-21 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rack
@@ -94,7 +93,6 @@ files:
 - setup.rb
 - test/test_clogger.rb
 - test/test_clogger_to_path.rb
-has_rdoc: true
 homepage: http://clogger.rubyforge.org/
 licenses: []
 
@@ -128,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: clogger
-rubygems_version: 1.6.1
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: configurable request logging for Rack