clogger 0.5.0 → 0.6.0

data/.document

@@ -4,3 +4,4 @@ ChangeLog
 lib
 ext/clogger_ext/clogger.c
 LICENSE
+LATEST

data/.gitignore

@@ -15,3 +15,4 @@ Makefile
 /ChangeLog
 /NEWS
 /GIT-VERSION-FILE
+/LATEST

data/.wrongdoc.yml

@@ -0,0 +1,5 @@
+---
+rdoc_url: http://clogger.rubyforge.org/
+cgit_url: http://git.bogomips.org/cgit/clogger.git
+git_url: git://git.bogomips.org/clogger.git
+changelog_since: 0.4.0

data/GIT-VERSION-GEN

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

data/GNUmakefile

@@ -1,7 +1,7 @@
 all:: test
 RUBY = ruby
 RAKE = rake
-GIT_URL = git://git.bogomips.org/clogger.git
+RSYNC = rsync
 
 GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
 	@./GIT-VERSION-GEN
@@ -26,24 +26,24 @@ test_unit := $(wildcard test/test_*.rb)
 test-unit: $(test_unit)
 
 ifeq ($(CLOGGER_PURE),)
-$(test_unit): export RUBYLIB := ext/clogger_ext:lib
+$(test_unit): mylib := ext/clogger_ext:lib
 $(test_unit): ext/clogger_ext/clogger.$(DLEXT)
 else
-$(test_unit): export RUBYLIB := lib
+$(test_unit): mylib := lib
 endif
 
 $(test_unit):
-	$(RUBY) $@
+	$(RUBY) -I $(mylib) $@
 
 test-ext:
-	CLOGGER_PURE=0 $(MAKE) test-unit
+	CLOGGER_PURE= $(MAKE) test-unit
 
 test-pure:
 	CLOGGER_PURE=1 $(MAKE) test-unit
 
 test: test-ext test-pure
 
-pkg_extra := GIT-VERSION-FILE NEWS ChangeLog
+pkg_extra := GIT-VERSION-FILE NEWS ChangeLog LATEST
 manifest: $(pkg_extra)
 	$(RM) .manifest
 	$(MAKE) .manifest
@@ -55,44 +55,25 @@ manifest: $(pkg_extra)
 	cmp $@+ $@ || mv $@+ $@
 	$(RM) $@+
 
-NEWS: GIT-VERSION-FILE .manifest
-	$(RAKE) -s news_rdoc > $@+
-	mv $@+ $@
-
-SINCE = 0.4.0
-ChangeLog: log_range = $(shell test -n "$(SINCE)" && echo v$(SINCE)..)
-ChangeLog: GIT-VERSION-FILE
-	@echo "ChangeLog from $(GIT_URL) ($(SINCE)..$(GIT_VERSION))" > $@+
-	@echo >> $@+
-	git log $(log_range) | sed -e 's/^/    /' >> $@+
-	mv $@+ $@
+ChangeLog: GIT-VERSION-FILE .wrongdoc.yml
+	wrongdoc prepare
 
-news_atom := http://clogger.rubyforge.org/NEWS.atom.xml
-cgit_atom := http://git.bogomips.org/cgit/clogger.git/atom/?h=master
-atom = <link rel="alternate" title="Atom feed" href="$(1)" \
-             type="application/atom+xml"/>
-
-doc: .document NEWS ChangeLog
-	rdoc -a -t "$(shell sed -ne '1s/^= //p' README)"
+doc: .document .wrongdoc.yml
+	find lib ext -type f -name '*.rbc' -exec rm -f '{}' ';'
+	$(RM) -r doc
+	wrongdoc all
 	install -m644 COPYING doc/COPYING
-	install -m644 $(shell grep '^[A-Z]' .document)  doc/
-	$(RUBY) -i -p -e \
-	  '$$_.gsub!("</title>",%q{\&$(call atom,$(cgit_atom))})' \
-	  doc/ChangeLog.html
-	$(RUBY) -i -p -e \
-	  '$$_.gsub!("</title>",%q{\&$(call atom,$(news_atom))})' \
-	  doc/NEWS.html doc/README.html
-	$(RAKE) -s news_atom > doc/NEWS.atom.xml
-	cd doc && ln README.html tmp && mv tmp index.html
+	install -m644 $(shell grep '^[A-Z]' .document) doc/
 
 # publishes docs to http://clogger.rubyforge.org/
 # this preserves timestamps as best as possible to help HTTP caches out
 # git set-file-times is here: http://git-scm.org/gitwiki/ExampleScripts
 publish_doc:
-	git set-file-times
-	$(RM) -r doc
+	-git set-file-times
 	$(MAKE) doc
-	rsync -av doc/ rubyforge.org:/var/www/gforge-projects/clogger/
+	-find doc/images -type f | \
+                TZ=UTC xargs touch -d '1970-01-01 00:00:03' doc/rdoc.css
+	$(RSYNC) -av doc/ rubyforge.org:/var/www/gforge-projects/clogger/
 	git ls-files | xargs touch
 
 ifneq ($(VERSION),)
@@ -106,10 +87,10 @@ release_changes := release_changes-$(VERSION)
 release-notes: $(release_notes)
 release-changes: $(release_changes)
 $(release_changes):
-	$(RAKE) -s release_changes > $@+
+	wrongdoc release_changes > $@+
 	$(VISUAL) $@+ && test -s $@+ && mv $@+ $@
 $(release_notes):
-	GIT_URL=$(GIT_URL) $(RAKE) -s release_notes > $@+
+	wrongdoc release_notes > $@+
 	$(VISUAL) $@+ && test -s $@+ && mv $@+ $@
 
 # ensures we're actually on the tagged $(VERSION), only used for release
@@ -140,8 +121,8 @@ $(pkgtgz): manifest fix-perms
 	@test -n "$(distdir)"
 	$(RM) -r $(distdir)
 	mkdir -p $(distdir)
-	tar c `cat .manifest` | (cd $(distdir) && tar x)
-	cd pkg && tar c $(basename $(@F)) | gzip -9 > $(@F)+
+	tar cf - `cat .manifest` | (cd $(distdir) && tar xf -)
+	cd pkg && tar cf - $(basename $(@F)) | gzip -9 > $(@F)+
 	mv $@+ $@
 
 package: $(pkgtgz) $(pkggem)

data/README

@@ -10,7 +10,7 @@ is customizable so you can specify exactly which fields to log.
 * highly customizable with easy-to-read nginx-like log format variables.
 
 * pre-defines Apache Common Log Format, Apache Combined Log Format and
-  Rack::CommonLogger (as distributed by Rack 1.0) formats.
+  Rack::CommonLogger (as distributed by Rack 1.0 and 1.1) formats.
   See Clogger::Format for the predefined formats.
 
 * Untrusted values are escaped (all HTTP headers, request URI components)
@@ -36,7 +36,7 @@ is customizable so you can specify exactly which fields to log.
   require "clogger"
   use Clogger,
       :format => Clogger::Format::Combined,
-      :logger => ::File.open("/path/to/log", "ab"),
+      :path => "/path/to/log",
       :reentrant => true
   run YourApplication.new
 
@@ -45,9 +45,15 @@ somewhere inside the "Rails::Initializer.run do |config|" block:
 
   config.middleware.use 'Clogger',
       :format => Clogger::Format::Combined,
-      :logger => ::File.open("/path/to/log", "ab"),
+      :path => "/path/to/log",
       :reentrant => false
 
+Instead of specifying a :path, you may also specify a :logger object
+that receives a "<<" method:
+
+  use Clogger, :logger=> $stdout, :reentrant => true
+  run YourApplication.new
+
 == VARIABLES
 
 * $http_* - HTTP request headers (e.g. $http_user_agent)

data/Rakefile

@@ -21,101 +21,8 @@ task :publish_news do
   rf.post_news('clogger', subject, body)
 end
 
-def tags
-  timefmt = '%Y-%m-%dT%H:%M:%SZ'
-  @tags ||= `git tag -l`.split(/\n/).map do |tag|
-    next if tag == "v0.0.0"
-    if %r{\Av[\d\.]+\z} =~ tag
-      header, subject, body = `git cat-file tag #{tag}`.split(/\n\n/, 3)
-      header = header.split(/\n/)
-      tagger = header.grep(/\Atagger /).first
-      body ||= "initial"
-      {
-        :time => Time.at(tagger.split(/ /)[-2].to_i).utc.strftime(timefmt),
-        :tagger_name => %r{^tagger ([^<]+)}.match(tagger)[1],
-        :tagger_email => %r{<([^>]+)>}.match(tagger)[1],
-        :id => `git rev-parse refs/tags/#{tag}`.chomp!,
-        :tag => tag,
-        :subject => subject,
-        :body => body,
-      }
-    end
-  end.compact.sort { |a,b| b[:time] <=> a[:time] }
-end
-
 cgit_url = "http://git.bogomips.org/cgit/clogger.git"
-git_url = ENV['GIT_URL'] || 'git://git.bogomips.org/clogger.git'
-
-desc 'prints news as an Atom feed'
-task :news_atom do
-  require 'nokogiri'
-  new_tags = tags[0,10]
-  puts(Nokogiri::XML::Builder.new do
-    feed :xmlns => "http://www.w3.org/2005/Atom" do
-      id! "http://clogger.rubyforge.org/NEWS.atom.xml"
-      title "Clogger news"
-      subtitle "configurable request logging for Rack"
-      link! :rel => 'alternate', :type => 'text/html',
-            :href => 'http://clogger.rubyforge.org/NEWS.html'
-      updated new_tags.first[:time]
-      new_tags.each do |tag|
-        entry do
-          title tag[:subject]
-          updated tag[:time]
-          published tag[:time]
-          author {
-            name tag[:tagger_name]
-            email tag[:tagger_email]
-          }
-          url = "#{cgit_url}/tag/?id=#{tag[:tag]}"
-          link! :rel => "alternate", :type => "text/html", :href =>url
-          id! url
-          content(:type => 'text') { tag[:body] }
-        end
-      end
-    end
-  end.to_xml)
-end
-
-desc 'prints RDoc-formatted news'
-task :news_rdoc do
-  tags.each do |tag|
-    time = tag[:time].tr!('T', ' ').gsub!(/:\d\dZ/, ' UTC')
-    puts "=== #{tag[:tag].sub(/^v/, '')} / #{time}"
-    puts ""
-
-    body = tag[:body]
-    puts tag[:body].gsub(/^/sm, "  ").gsub(/[ \t]+$/sm, "")
-    puts ""
-  end
-end
-
-desc "print release changelog for Rubyforge"
-task :release_changes do
-  version = ENV['VERSION'] or abort "VERSION= needed"
-  version = "v#{version}"
-  vtags = tags.map { |tag| tag[:tag] =~ /\Av/ and tag[:tag] }.sort
-  prev = vtags[vtags.index(version) - 1]
-  system('git', 'diff', '--stat', prev, version) or abort $?
-  puts ""
-  system('git', 'log', "#{prev}..#{version}") or abort $?
-end
-
-desc "print release notes for Rubyforge"
-task :release_notes do
-  require 'rubygems'
-
-  spec = Gem::Specification.load('clogger.gemspec')
-  puts spec.description.strip
-  puts ""
-  puts "* #{spec.homepage}"
-  puts "* #{spec.email}"
-  puts "* #{git_url}"
-
-  _, _, body = `git cat-file tag v#{spec.version}`.split(/\n\n/, 3)
-  print "\nChanges:\n\n"
-  puts body
-end
+git_url = 'git://git.bogomips.org/clogger.git'
 
 desc "post to RAA"
 task :raa_update do

data/clogger.gemspec

@@ -1,44 +1,28 @@
 ENV["VERSION"] or abort "VERSION= must be specified"
 manifest = File.readlines('.manifest').map! { |x| x.chomp! }
+require 'wrongdoc'
+extend Wrongdoc::Gemspec
+name, summary, title = readme_metadata
 
 Gem::Specification.new do |s|
   s.name = %q{clogger}
-  s.version = ENV["VERSION"]
-
-  if s.respond_to? :required_rubygems_version=
-    s.required_rubygems_version = Gem::Requirement.new(">= 0")
-  end
-  s.homepage = 'http://clogger.rubyforge.org/'
+  s.version = ENV["VERSION"].dup
+  s.homepage = Wrongdoc.config[:rdoc_url]
   s.authors = ["cloggers"]
   s.date = Time.now.utc.strftime('%Y-%m-%d')
-  s.description = %q{
-Clogger is Rack middleware for logging HTTP requests.  The log format
-is customizable so you can specify exactly which fields to log.
-}.strip
+  s.description = readme_description
   s.email = %q{clogger@librelist.com}
-
-  s.extra_rdoc_files = File.readlines('.document').map! do |x|
-    x.chomp!
-    if File.directory?(x)
-      manifest.grep(%r{\A#{x}/})
-    elsif File.file?(x)
-      x
-    else
-      nil
-    end
-  end.flatten.compact
-
+  s.extra_rdoc_files = extra_rdoc_files(manifest)
   s.files = manifest
-  s.rdoc_options = [ "-Na",
-                     "-t", "Clogger - configurable request logging for Rack"
-                   ]
+  s.rdoc_options = rdoc_options
   s.require_paths = %w(lib ext)
   s.rubyforge_project = %q{clogger}
-  s.summary = %q{configurable request logging for Rack}
+  s.summary = summary
   s.test_files = %w(test/test_clogger.rb test/test_clogger_to_path.rb)
 
   # HeaderHash wasn't case-insensitive in old versions
   s.add_dependency(%q<rack>, ["> 0.9"])
+  s.add_development_dependency(%q<wrongdoc>, "~> 1.0")
   s.extensions = %w(ext/clogger_ext/extconf.rb)
 
   # s.license = "LGPLv2.1+" # disabled for compatibility with older RubyGems

data/ext/clogger_ext/clogger.c

@@ -1,4 +1,3 @@
-#define _BSD_SOURCE
 #include <ruby.h>
 #ifdef HAVE_RUBY_IO_H
 #  include <ruby/io.h>
@@ -10,25 +9,23 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/time.h>
-#include <time.h>
 #include <errno.h>
 #ifdef HAVE_FCNTL_H
 #  include <fcntl.h>
 #endif
+#define _POSIX_C_SOURCE 200112L
+#include <time.h>
 #include "ruby_1_9_compat.h"
 
-/* in case _BSD_SOURCE doesn't give us this macro */
-#ifndef timersub
-#  define timersub(a, b, result) \
-do { \
-	(result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
-	(result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
-	if ((result)->tv_usec < 0) { \
-		--(result)->tv_sec; \
-		(result)->tv_usec += 1000000; \
-	} \
-} while (0)
-#endif
+static void clock_diff(struct timespec *a, const struct timespec *b)
+{
+	a->tv_sec -= b->tv_sec;
+	a->tv_nsec -= b->tv_nsec;
+	if (a->tv_nsec < 0) {
+		--a->tv_sec;
+		a->tv_nsec += 1000000000;
+	}
+}
 
 /* give GCC hints for better branch prediction
  * (we layout branches so that ASCII characters are handled faster) */
@@ -78,7 +75,7 @@ struct clogger {
 	VALUE body;
 
 	off_t body_bytes_sent;
-	struct timeval tv_start;
+	struct timespec ts_start;
 
 	int fd;
 	int wrap_body;
@@ -213,11 +210,6 @@ static VALUE obj_fileno(VALUE obj)
 	return rb_funcall(obj, rb_intern("fileno"), 0);
 }
 
-static VALUE obj_enable_sync(VALUE obj)
-{
-	return rb_funcall(obj, rb_intern("sync="), 1, Qtrue);
-}
-
 /* only for writing to regular files, not stupid crap like NFS  */
 static void write_full(int fd, const void *buf, size_t count)
 {
@@ -341,34 +333,40 @@ static void append_body_bytes_sent(struct clogger *c)
 	rb_str_buf_cat(c->log_buf, buf, nr);
 }
 
-static void append_tv(struct clogger *c, const VALUE *op, struct timeval *tv)
+static void append_ts(struct clogger *c, const VALUE *op, struct timespec *ts)
 {
-	char buf[sizeof(".000000") + ((sizeof(tv->tv_sec) * 8) / 3)];
+	char buf[sizeof(".000000") + ((sizeof(ts->tv_sec) * 8) / 3)];
 	int nr;
 	char *fmt = RSTRING_PTR(op[1]);
 	int ndiv = NUM2INT(op[2]);
+	int usec = ts->tv_nsec / 1000;
 
 	nr = snprintf(buf, sizeof(buf), fmt,
-		      (int)tv->tv_sec, (int)(tv->tv_usec / ndiv));
+		      (int)ts->tv_sec, (int)(usec / ndiv));
 	assert(nr > 0 && nr < (int)sizeof(buf));
 	rb_str_buf_cat(c->log_buf, buf, nr);
 }
 
 static void append_request_time_fmt(struct clogger *c, const VALUE *op)
 {
-	struct timeval now, d;
+	struct timespec now;
+	int r = clock_gettime(CLOCK_MONOTONIC, &now);
+
+	if (unlikely(r != 0))
+		rb_sys_fail("clock_gettime(CLOCK_MONONTONIC)");
 
-	gettimeofday(&now, NULL);
-	timersub(&now, &c->tv_start, &d);
-	append_tv(c, op, &d);
+	clock_diff(&now, &c->ts_start);
+	append_ts(c, op, &now);
 }
 
 static void append_time_fmt(struct clogger *c, const VALUE *op)
 {
-	struct timeval now;
+	struct timespec now;
+	int r = clock_gettime(CLOCK_REALTIME, &now);
 
-	gettimeofday(&now, NULL);
-	append_tv(c, op, &now);
+	if (unlikely(r != 0))
+		rb_sys_fail("clock_gettime(CLOCK_REALTIME)");
+	append_ts(c, op, &now);
 }
 
 static void append_request_uri(struct clogger *c)
@@ -588,12 +586,35 @@ static VALUE cwrite(struct clogger *c)
 	return Qnil;
 }
 
+static void init_logger(struct clogger *c, VALUE path)
+{
+	ID id;
+
+	if (!NIL_P(path) && !NIL_P(c->logger))
+		rb_raise(rb_eArgError, ":logger and :path are independent");
+	if (!NIL_P(path)) {
+		VALUE ab = rb_str_new2("ab");
+		id = rb_intern("open");
+		c->logger = rb_funcall(rb_cFile, id, 2, path, ab);
+	}
+
+	id = rb_intern("sync=");
+	if (rb_respond_to(c->logger, id))
+		rb_funcall(c->logger, id, 1, Qtrue);
+
+	id = rb_intern("fileno");
+	if (rb_respond_to(c->logger, id))
+		c->fd = raw_fd(rb_funcall(c->logger, id, 0));
+}
+
 /**
  * call-seq:
  *   Clogger.new(app, :logger => $stderr, :format => string) => obj
  *
  * 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.
  */
 static VALUE clogger_init(int argc, VALUE *argv, VALUE self)
 {
@@ -609,12 +630,9 @@ static VALUE clogger_init(int argc, VALUE *argv, VALUE self)
 	if (TYPE(o) == T_HASH) {
 		VALUE tmp;
 
+		tmp = rb_hash_aref(o, ID2SYM(rb_intern("path")));
 		c->logger = rb_hash_aref(o, ID2SYM(rb_intern("logger")));
-		if (!NIL_P(c->logger)) {
-			rb_rescue(obj_enable_sync, c->logger, NULL, 0);
-			tmp = rb_rescue(obj_fileno, c->logger, NULL, 0);
-			c->fd = raw_fd(tmp);
-		}
+		init_logger(c, tmp);
 
 		tmp = rb_hash_aref(o, ID2SYM(rb_intern("format")));
 		if (!NIL_P(tmp))
@@ -710,7 +728,7 @@ static VALUE ccall(struct clogger *c, VALUE env)
 {
 	VALUE rv;
 
-	gettimeofday(&c->tv_start, NULL);
+	clock_gettime(CLOCK_MONOTONIC, &c->ts_start);
 	c->env = env;
 	c->cookies = Qfalse;
 	rv = rb_funcall(c->app, call_id, 1, env);
@@ -800,9 +818,17 @@ static VALUE clogger_init_copy(VALUE clone, VALUE orig)
 
 #define CONST_GLOBAL_STR(val) CONST_GLOBAL_STR2(val, #val)
 
+#ifdef RSTRUCT_PTR
+#  define ToPath_clogger(tp) RSTRUCT_PTR(tp)[0]
+#else
+static ID clogger_id;
+#  define ToPath_clogger(tp) rb_funcall(tp,clogger_id,0)
+#endif
+
 static VALUE to_path(VALUE self)
 {
-	struct clogger *c = clogger_get(RSTRUCT_PTR(self)[0]);
+	VALUE my_clogger = ToPath_clogger(self);
+	struct clogger *c = clogger_get(my_clogger);
 	VALUE path = rb_funcall(c->body, to_path_id, 0);
 	struct stat sb;
 	int rv;
@@ -879,4 +905,7 @@ void Init_clogger_ext(void)
 	cHeaderHash = rb_const_get(tmp, rb_intern("HeaderHash"));
 	cToPath = rb_const_get(cClogger, rb_intern("ToPath"));
 	rb_define_method(cToPath, "to_path", to_path, 0);
+#ifndef RSTRUCT_PTR
+	clogger_id = rb_intern("clogger");
+#endif
 }

data/ext/clogger_ext/extconf.rb

@@ -13,6 +13,10 @@ begin
     have_macro('O_NONBLOCK', %w(unistd.h fcntl.h))
   end
 
+  unless have_macro('CLOCK_MONOTONIC', 'time.h', '-D_POSIX_C_SOURCE=200112L')
+    $CPPFLAGS += '-D_POSIX_SOURCE_200112L'
+    have_func('CLOCK_MONOTONIC', 'time.h')
+  end
   have_func('localtime_r', 'time.h') or raise "localtime_r needed"
   have_func('gmtime_r', 'time.h') or raise "gmtime_r needed"
   have_func('rb_str_set_len', 'ruby.h')

data/ext/clogger_ext/ruby_1_9_compat.h

@@ -11,11 +11,13 @@
 #ifndef RARRAY_LEN
 #  define RARRAY_LEN(s) (RARRAY(s)->len)
 #endif
-#ifndef RSTRUCT_PTR
-#  define RSTRUCT_PTR(s) (RSTRUCT(s)->ptr)
-#endif
-#ifndef RSTRUCT_LEN
-#  define RSTRUCT_LEN(s) (RSTRUCT(s)->len)
+#ifndef RUBINIUS
+#  ifndef RSTRUCT_PTR
+#    define RSTRUCT_PTR(s) (RSTRUCT(s)->ptr)
+#  endif
+#  ifndef RSTRUCT_LEN
+#    define RSTRUCT_LEN(s) (RSTRUCT(s)->len)
+#  endif
 #endif
 
 #ifndef HAVE_RB_STR_SET_LEN

data/lib/clogger.rb

@@ -4,8 +4,8 @@ require 'rack'
 # See the README for usage instructions
 class Clogger
 
-  # the version of Clogger, currently 0.5.0
-  VERSION = '0.5.0'
+  # the version of Clogger, currently 0.6.0
+  VERSION = '0.6.0'
 
   # :stopdoc:
   OP_LITERAL = 0
@@ -57,7 +57,7 @@ private
          path_info query_string script_name
          server_name server_port
          auth_type gateway_interface server_software path_translated
-         ).join('|') << ')\z').freeze
+         ).join('|') << ')\z')
 
   SCAN = /([^$]*)(\$+(?:env\{\w+(?:\.[\w\.]+)?\}|
                         e\{[^\}]+\}|
@@ -73,28 +73,28 @@ private
 
       unless tok.nil?
         if tok.sub!(/\A(\$+)\$/, '$')
-          rv << [ OP_LITERAL, $1.dup ]
+          rv << [ OP_LITERAL, $1 ]
         end
 
         compat = ALIASES[tok] and tok = compat
 
         case tok
         when /\A(\$*)\z/
-          rv << [ OP_LITERAL, $1.dup ]
+          rv << [ OP_LITERAL, $1 ]
         when /\A\$env\{(\w+(?:\.[\w\.]+))\}\z/
-          rv << [ OP_REQUEST, $1.freeze ]
+          rv << [ OP_REQUEST, $1 ]
         when /\A\$e\{([^\}]+)\}\z/
-          rv << [ OP_EVAL, $1.dup ]
+          rv << [ OP_EVAL, $1 ]
         when /\A\$cookie_(\w+)\z/
-          rv << [ OP_COOKIE, $1.dup.freeze ]
+          rv << [ OP_COOKIE, $1 ]
         when CGI_ENV, /\A\$(http_\w+)\z/
-          rv << [ OP_REQUEST, $1.upcase.freeze ]
+          rv << [ OP_REQUEST, $1.upcase ]
         when /\A\$sent_http_(\w+)\z/
-          rv << [ OP_RESPONSE, $1.downcase.tr('_','-').freeze ]
+          rv << [ OP_RESPONSE, $1.downcase.tr('_','-') ]
         when /\A\$time_local\{([^\}]+)\}\z/
-          rv << [ OP_TIME_LOCAL, $1.dup ]
+          rv << [ OP_TIME_LOCAL, $1 ]
         when /\A\$time_utc\{([^\}]+)\}\z/
-          rv << [ OP_TIME_UTC, $1.dup ]
+          rv << [ OP_TIME_UTC, $1 ]
         when /\A\$time\{(\d+)\}\z/
           rv << [ OP_TIME, *usec_conv_pair(tok, $1.to_i) ]
         when /\A\$request_time\{(\d+)\}\z/

data/lib/clogger/format.rb

@@ -7,19 +7,19 @@ class Clogger
     # common log format used by Apache:
     # http://httpd.apache.org/docs/2.2/logs.html
     Common = "$remote_addr - $remote_user [$time_local] " \
-             '"$request" $status $response_length'.freeze
+             '"$request" $status $response_length'
 
     # combined log format used by Apache:
     # http://httpd.apache.org/docs/2.2/logs.html
-    Combined = %Q|#{Common} "$http_referer" "$http_user_agent"|.freeze
+    Combined = %Q|#{Common} "$http_referer" "$http_user_agent"|
 
     # combined log format used by nginx:
     # http://wiki.nginx.org/NginxHttpLogModule
-    NginxCombined = Combined.gsub(/response_length/, 'body_bytes_sent').freeze
+    NginxCombined = Combined.gsub(/response_length/, 'body_bytes_sent')
 
     # log format used by Rack 1.0
     Rack_1_0 = "$ip - $remote_user [$time_local{%d/%b/%Y %H:%M:%S}] " \
-               '"$request" $status $response_length $request_time{4}'.freeze
+               '"$request" $status $response_length $request_time{4}'
   end
 
 end

data/lib/clogger/pure.rb

@@ -14,7 +14,12 @@ class Clogger
 
     @app = app
     @logger = opts[:logger]
-    (@logger.sync = true) rescue nil
+    path = opts[:path]
+    path && @logger and
+      raise ArgumentError, ":logger and :path are independent"
+    path and @logger = File.open(path, "ab")
+
+    @logger.sync = true if @logger.respond_to?(:sync=)
     @fmt_ops = compile_format(opts[:format] || Format::Common, opts)
     @wrap_body = need_wrap_body?(@fmt_ops)
     @reentrant = opts[:reentrant]
@@ -69,7 +74,7 @@ class Clogger
   end
 
   def fileno
-    @logger.fileno rescue nil
+    @logger.respond_to?(:fileno) ? @logger.fileno : nil
   end
 
 private
@@ -138,7 +143,7 @@ private
         time_format(t.to_i, (t - t.to_i) * 1000000, op[1], op[2])
       when OP_TIME
         t = Time.now
-        time_format(t.sec, t.usec, op[1], op[2])
+        time_format(t.to_i, t.usec, op[1], op[2])
       when OP_COOKIE
         (env['rack.request.cookie_hash'][op[1]] rescue "-") || "-"
       else

data/test/test_clogger.rb

@@ -3,6 +3,7 @@ $stderr.sync = $stdout.sync = true
 require "test/unit"
 require "date"
 require "stringio"
+require "tempfile"
 
 require "rack"
 
@@ -240,32 +241,52 @@ class TestClogger < Test::Unit::TestCase
     str = StringIO.new
     app = lambda { |env| [ 200, {}, [] ] }
     cl = Clogger.new(app, :logger => str, :format => '$msec')
+    a = Time.now.to_f - 0.001
     status, header, bodies = cl.call(@req)
     assert_match %r(\A\d+\.\d{3}\n\z), str.string
+    b = Time.now.to_f + 0.001
+    logged = str.string.to_f
+    assert logged >= a, "#{logged} >= #{a}"
+    assert logged <= b, "#{logged} <= #{b}"
   end
 
   def test_usec
     str = StringIO.new
     app = lambda { |env| [ 200, {}, [] ] }
     cl = Clogger.new(app, :logger => str, :format => '$usec')
+    a = Time.now.to_f - 0.000001
     status, header, bodies = cl.call(@req)
     assert_match %r(\A\d+\.\d{6}\n\z), str.string
+    b = Time.now.to_f + 0.000001
+    logged = str.string.to_f
+    assert logged >= a, "#{logged} >= #{a}"
+    assert logged <= b, "#{logged} <= #{b}"
   end
 
   def test_time_0
     str = StringIO.new
     app = lambda { |env| [ 200, {}, [] ] }
     cl = Clogger.new(app, :logger => str, :format => '$time{0}')
+    a = Time.now.to_f - 1
     status, header, bodies = cl.call(@req)
     assert_match %r(\A\d+\n\z), str.string
+    b = Time.now.to_f + 1
+    logged = str.string.to_f
+    assert logged >= a, "#{logged} >= #{a}"
+    assert logged <= b, "#{logged} <= #{b}"
   end
 
   def test_time_1
     str = StringIO.new
     app = lambda { |env| [ 200, {}, [] ] }
     cl = Clogger.new(app, :logger => str, :format => '$time{1}')
+    a = Time.now.to_f - 0.5
     status, header, bodies = cl.call(@req)
     assert_match %r(\A\d+\.\d\n\z), str.string
+    b = Time.now.to_f + 0.5
+    logged = str.string.to_f
+    assert logged >= a, "#{logged} >= #{a}"
+    assert logged <= b, "#{logged} <= #{b}"
   end
 
   def test_request_length
@@ -629,4 +650,31 @@ class TestClogger < Test::Unit::TestCase
     end
   end if RUBY_PLATFORM =~ /linux/ && File.readable?(LINUX_PROC_PID_STATUS)
 
+  def test_path_open_file
+    tmp = Tempfile.new('test_clogger')
+    app = lambda { |env| [ 200, {}, [] ] }
+    app = Clogger.new(app, :format => '$status', :path => tmp.path)
+    assert_kind_of Integer, app.fileno
+    assert app.fileno != tmp.fileno
+    status, headers, body = app.call(@req)
+    assert_equal "200\n", tmp.read
+  end
+
+  def test_path_logger_conflict
+    tmp = Tempfile.new('test_clogger')
+    app = lambda { |env| [ 200, {}, [] ] }
+    assert_raises(ArgumentError) {
+      Clogger.new(app, :logger=> $stderr, :path => tmp.path)
+    }
+  end
+
+  def test_request_time
+    s = []
+    app = lambda { |env| sleep(0.1) ; [302, [], [] ] }
+    cl = Clogger.new(app, :logger => s, :format => "$request_time")
+    status, headers, body = cl.call(@req)
+    assert_nothing_raised { body.each { |x| } ; body.close }
+    assert s[-1].to_f >= 0.100
+    assert s[-1].to_f <= 0.110
+  end
 end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: clogger
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  hash: 7
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - cloggers
@@ -9,22 +15,40 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-06 00:00:00 +00:00
+date: 2010-12-25 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rack
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">"
       - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 9
         version: "0.9"
-    version: 
-description: |-
-  Clogger is Rack middleware for logging HTTP requests.  The log format
-  is customizable so you can specify exactly which fields to log.
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: wrongdoc
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :development
+  version_requirements: *id002
+description: == DESCRIPTION
 email: clogger@librelist.com
 executables: []
 
@@ -39,15 +63,18 @@ extra_rdoc_files:
 - lib/clogger/pure.rb
 - ext/clogger_ext/clogger.c
 - LICENSE
+- LATEST
 files: 
 - .document
 - .gitignore
 - .manifest
+- .wrongdoc.yml
 - COPYING
 - ChangeLog
 - GIT-VERSION-FILE
 - GIT-VERSION-GEN
 - GNUmakefile
+- LATEST
 - LICENSE
 - NEWS
 - README
@@ -68,28 +95,35 @@ licenses: []
 
 post_install_message: 
 rdoc_options: 
-- -Na
 - -t
-- Clogger - configurable request logging for Rack
+- \Clogger - configurable request logging for Rack
+- -W
+- http://git.bogomips.org/cgit/clogger.git/tree/%s
 require_paths: 
 - lib
 - ext
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: clogger
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: configurable request logging for Rack