clogger 0.4.0 → 0.5.0

data/GIT-VERSION-GEN

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

data/GNUmakefile

@@ -22,11 +22,24 @@ clean:
 	-$(MAKE) -C ext/clogger_ext clean
 	$(RM) ext/clogger_ext/Makefile lib/clogger_ext.$(DLEXT)
 
-test-ext: ext/clogger_ext/clogger.$(DLEXT)
-	$(RUBY) -Iext/clogger_ext:lib test/test_clogger.rb
+test_unit := $(wildcard test/test_*.rb)
+test-unit: $(test_unit)
+
+ifeq ($(CLOGGER_PURE),)
+$(test_unit): export RUBYLIB := ext/clogger_ext:lib
+$(test_unit): ext/clogger_ext/clogger.$(DLEXT)
+else
+$(test_unit): export RUBYLIB := lib
+endif
+
+$(test_unit):
+	$(RUBY) $@
+
+test-ext:
+	CLOGGER_PURE=0 $(MAKE) test-unit
 
 test-pure:
-	CLOGGER_PURE=t $(RUBY) -Ilib test/test_clogger.rb
+	CLOGGER_PURE=1 $(MAKE) test-unit
 
 test: test-ext test-pure
 
@@ -46,7 +59,7 @@ NEWS: GIT-VERSION-FILE .manifest
 	$(RAKE) -s news_rdoc > $@+
 	mv $@+ $@
 
-SINCE = 0.3.2
+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))" > $@+
@@ -60,7 +73,7 @@ atom = <link rel="alternate" title="Atom feed" href="$(1)" \
              type="application/atom+xml"/>
 
 doc: .document NEWS ChangeLog
-	rdoc -Na -t "$(shell sed -ne '1s/^= //p' README)"
+	rdoc -a -t "$(shell sed -ne '1s/^= //p' README)"
 	install -m644 COPYING doc/COPYING
 	install -m644 $(shell grep '^[A-Z]' .document)  doc/
 	$(RUBY) -i -p -e \
@@ -145,3 +158,4 @@ gem install-gem: GIT-VERSION-FILE
 endif
 
 .PHONY: .FORCE-GIT-VERSION-FILE test doc manifest
+.PHONY: test test-ext test-pure $(test_unit)

data/LICENSE

@@ -0,0 +1,16 @@
+\Clogger is copyrighted Free Software by all contributors, see logs in
+revision control for names and email addresses of all of them.
+
+You can redistribute it and/or modify it under the terms of the GNU Lesser
+General Public License as published by the Free Software Foundation,
+version 2.1 or later {LGPLv2.1}[http://www.gnu.org/licenses/lgpl-2.1.txt]
+(see link:COPYING).
+
+\Clogger is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301

data/README

@@ -1,8 +1,8 @@
-= Clogger - configurable request logging for Rack
+= \Clogger - configurable request logging for Rack
 
 == DESCRIPTION
 
-Clogger is Rack middleware for logging HTTP requests.  The log format
+\Clogger is Rack middleware for logging HTTP requests.  The log format
 is customizable so you can specify exactly which fields to log.
 
 == FEATURES
@@ -21,13 +21,18 @@ is customizable so you can specify exactly which fields to log.
     all bytes in the range of \x00-\x1F
 
 * multi-instance capable and (optionally) reentrant.  You can use
-  Clogger in a multi-threaded server, and even multiple Cloggers logging
+  \Clogger in a multi-threaded server, and even multiple Cloggers logging
   to different locations and different formats in the same process.
 
+* Pure Ruby version for non-MRI versions of Ruby (or via CLOGGER_PURE=1
+  in the environment).  The optional C extension is loaded by default
+  and supported under MRI 1.8.7, 1.9.1, and 1.9.2.
+
 == SYNOPSIS
 
-Clogger may be loaded as Rack middleware in your config.ru:
+\Clogger may be loaded as Rack middleware in your config.ru:
 
+  # ENV['CLOGGER_PURE'] = '1' # uncomment to disable C extension
   require "clogger"
   use Clogger,
       :format => Clogger::Format::Combined,
@@ -81,7 +86,7 @@ somewhere inside the "Rails::Initializer.run do |config|" block:
 
 == REQUIREMENTS
 
-* Ruby, Rack
+* {Ruby}[http://ruby-lang.org/], {Rack}[http://rack.rubyforge.org/]
 
 == DEVELOPMENT
 
@@ -126,20 +131,3 @@ There is an optional C extension that should be compatible with MRI
 other Ruby implementations, but be sure to let us know if that's not the
 case.  No pre-built binaries are currently distributed, let us know if
 you're interested in helping with the release/support effort.
-
-== LICENSE
-
-Copyright (C) 2009 Eric Wong and contributors.
-
-Clogger is free software; you can redistribute it and/or modify it under
-the terms of the GNU Lesser General Public License as published by the
-Free Software Foundation, version 3.0.
-
-Clogger is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-License in the COPYING file for more details.
-
-You should have received a copy of the GNU Lesser General Public License
-along with Clogger; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301

data/clogger.gemspec

@@ -35,11 +35,11 @@ is customizable so you can specify exactly which fields to log.
   s.require_paths = %w(lib ext)
   s.rubyforge_project = %q{clogger}
   s.summary = %q{configurable request logging for Rack}
-  s.test_files = %w(test/test_clogger.rb)
+  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.extensions = %w(ext/clogger_ext/extconf.rb)
 
-  # s.license = "LGPLv3" # disabled for compatibility with older RubyGems
+  # s.license = "LGPLv2.1+" # disabled for compatibility with older RubyGems
 end

data/ext/clogger_ext/clogger.c

@@ -1,8 +1,14 @@
 #define _BSD_SOURCE
 #include <ruby.h>
+#ifdef HAVE_RUBY_IO_H
+#  include <ruby/io.h>
+#else
+#  include <rubyio.h>
+#endif
 #include <assert.h>
 #include <unistd.h>
 #include <sys/types.h>
+#include <sys/stat.h>
 #include <sys/time.h>
 #include <time.h>
 #include <errno.h>
@@ -89,7 +95,10 @@ static ID to_s_id;
 static ID size_id;
 static ID sq_brace_id;
 static ID new_id;
+static ID to_path_id;
+static ID to_io_id;
 static VALUE cClogger;
+static VALUE cToPath;
 static VALUE mFormat;
 static VALUE cHeaderHash;
 
@@ -237,21 +246,31 @@ static void write_full(int fd, const void *buf, size_t count)
  * allow us to use write_full() iff we detect a blocking file
  * descriptor that wouldn't play nicely with Ruby threading/fibers
  */
-static int raw_fd(VALUE my_fileno)
+static int raw_fd(VALUE my_fd)
 {
 #if defined(HAVE_FCNTL) && defined(F_GETFL) && defined(O_NONBLOCK)
 	int fd;
 	int flags;
 
-	if (NIL_P(my_fileno))
+	if (NIL_P(my_fd))
 		return -1;
-	fd = NUM2INT(my_fileno);
+	fd = NUM2INT(my_fd);
 
 	flags = fcntl(fd, F_GETFL);
 	if (flags < 0)
 		rb_sys_fail("fcntl");
 
-	return (flags & O_NONBLOCK) ? -1 : fd;
+	if (flags & O_NONBLOCK) {
+		struct stat sb;
+
+		if (fstat(fd, &sb) < 0)
+			return -1;
+
+		/* O_NONBLOCK is no-op for regular files: */
+		if (! S_ISREG(sb.st_mode))
+			return -1;
+	}
+	return fd;
 #else /* platforms w/o fcntl/F_GETFL/O_NONBLOCK */
 	return -1;
 #endif /* platforms w/o fcntl/F_GETFL/O_NONBLOCK */
@@ -638,12 +657,11 @@ static VALUE body_iter_i(VALUE str, VALUE memop)
 	return rb_yield(str);
 }
 
-static VALUE wrap_each(struct clogger *c)
+static VALUE body_close(struct clogger *c)
 {
-	c->body_bytes_sent = 0;
-	rb_iterate(rb_each, c->body, body_iter_i, (VALUE)&c->body_bytes_sent);
-
-	return c->body;
+	if (rb_respond_to(c->body, close_id))
+		return rb_funcall(c->body, close_id, 0);
+	return Qnil;
 }
 
 /**
@@ -659,8 +677,10 @@ static VALUE clogger_each(VALUE self)
 	struct clogger *c = clogger_get(self);
 
 	rb_need_block();
+	c->body_bytes_sent = 0;
+	rb_iterate(rb_each, c->body, body_iter_i, (VALUE)&c->body_bytes_sent);
 
-	return rb_ensure(wrap_each, (VALUE)c, cwrite, (VALUE)c);
+	return self;
 }
 
 /**
@@ -675,9 +695,7 @@ static VALUE clogger_close(VALUE self)
 {
 	struct clogger *c = clogger_get(self);
 
-	if (rb_respond_to(c->body, close_id))
-		return rb_funcall(c->body, close_id, 0);
-	return Qnil;
+	return rb_ensure(body_close, (VALUE)c, cwrite, (VALUE)c);
 }
 
 /* :nodoc: */
@@ -749,6 +767,9 @@ static VALUE clogger_call(VALUE self, VALUE env)
 
 		rv = ccall(c, env);
 		assert(!OBJ_FROZEN(rv) && "frozen response array");
+
+		if (rb_respond_to(c->body, to_path_id))
+			self = rb_funcall(cToPath, new_id, 1, self);
 		rb_ary_store(rv, 2, self);
 
 		return rv;
@@ -779,6 +800,39 @@ static VALUE clogger_init_copy(VALUE clone, VALUE orig)
 
 #define CONST_GLOBAL_STR(val) CONST_GLOBAL_STR2(val, #val)
 
+static VALUE to_path(VALUE self)
+{
+	struct clogger *c = clogger_get(RSTRUCT_PTR(self)[0]);
+	VALUE path = rb_funcall(c->body, to_path_id, 0);
+	struct stat sb;
+	int rv;
+	unsigned devfd;
+	const char *cpath;
+
+	Check_Type(path, T_STRING);
+	cpath = RSTRING_PTR(path);
+
+	/* try to avoid an extra path lookup  */
+	if (rb_respond_to(c->body, to_io_id))
+		rv = fstat(my_fileno(c->body), &sb);
+	/*
+	 * Rainbows! can use "/dev/fd/%u" in to_path output to avoid
+	 * extra open() syscalls, too.
+	 */
+	else if (sscanf(cpath, "/dev/fd/%u", &devfd) == 1)
+		rv = fstat((int)devfd, &sb);
+	else
+		rv = stat(cpath, &sb);
+
+	/*
+	 * calling this method implies the web server will bypass
+	 * the each method where body_bytes_sent is calculated,
+	 * so we stat and set that value here.
+	 */
+	c->body_bytes_sent = rv == 0 ? sb.st_size : 0;
+	return path;
+}
+
 void Init_clogger_ext(void)
 {
 	VALUE tmp;
@@ -792,6 +846,8 @@ void Init_clogger_ext(void)
 	size_id = rb_intern("size");
 	sq_brace_id = rb_intern("[]");
 	new_id = rb_intern("new");
+	to_path_id = rb_intern("to_path");
+	to_io_id = rb_intern("to_io");
 	cClogger = rb_define_class("Clogger", rb_cObject);
 	mFormat = rb_define_module_under(cClogger, "Format");
 	rb_define_alloc_func(cClogger, clogger_alloc);
@@ -821,4 +877,6 @@ void Init_clogger_ext(void)
 	tmp = rb_const_get(rb_cObject, rb_intern("Rack"));
 	tmp = rb_const_get(tmp, rb_intern("Utils"));
 	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);
 }

data/ext/clogger_ext/ruby_1_9_compat.h

@@ -11,6 +11,12 @@
 #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)
+#endif
 
 #ifndef HAVE_RB_STR_SET_LEN
 /* this is taken from Ruby 1.8.7, 1.8.6 may not have it */
@@ -21,3 +27,34 @@ static void rb_18_str_set_len(VALUE str, long len)
 }
 #define rb_str_set_len(str,len) rb_18_str_set_len(str,len)
 #endif
+
+#if ! HAVE_RB_IO_T
+#  define rb_io_t OpenFile
+#endif
+
+#ifdef GetReadFile
+#  define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
+#else
+#  if !HAVE_RB_IO_T || (RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8)
+#    define FPTR_TO_FD(fptr) fileno(fptr->f)
+#  else
+#    define FPTR_TO_FD(fptr) fptr->fd
+#  endif
+#endif
+
+static int my_fileno(VALUE io)
+{
+	rb_io_t *fptr;
+
+	for (;;) {
+		switch (TYPE(io)) {
+		case T_FILE: {
+			GetOpenFile(io, fptr);
+			return FPTR_TO_FD(fptr);
+		}
+		default:
+			io = rb_convert_type(io, T_FILE, "IO", "to_io");
+			/* retry */
+		}
+	}
+}

data/lib/clogger.rb

@@ -1,9 +1,13 @@
 # -*- encoding: binary -*-
-autoload :Rack, 'rack'
+require 'rack'
 
+# See the README for usage instructions
 class Clogger
-  VERSION = '0.4.0'
 
+  # the version of Clogger, currently 0.5.0
+  VERSION = '0.5.0'
+
+  # :stopdoc:
   OP_LITERAL = 0
   OP_REQUEST = 1
   OP_RESPONSE = 2
@@ -36,6 +40,15 @@ class Clogger
     :request_uri => 7
   }
 
+  # proxy class to avoid clobbering the +to_path+ optimization when
+  # using static files
+  class ToPath < Struct.new(:clogger)
+    def each(&block); clogger.each(&block); end
+    def close; clogger.close; end
+
+    # to_path is defined in Clogger::Pure or the C extension
+  end
+
 private
 
   CGI_ENV = Regexp.new('\A\$(' <<
@@ -132,12 +145,13 @@ private
     end
   end
 
+  # :startdoc:
 end
 
 require 'clogger/format'
 
 begin
-  raise LoadError if ENV['CLOGGER_PURE']
+  raise LoadError if ENV['CLOGGER_PURE'].to_i != 0
   require 'clogger_ext'
 rescue LoadError
   require 'clogger/pure'

data/lib/clogger/pure.rb

@@ -5,6 +5,9 @@
 # the original C extension code so it's not very Ruby-ish...
 class Clogger
 
+  attr_accessor :env, :status, :headers, :body
+  attr_writer :body_bytes_sent
+
   def initialize(app, opts = {})
     # trigger autoload to avoid thread-safety issues later on
     Rack::Utils::HeaderHash.new({})
@@ -30,8 +33,13 @@ class Clogger
     headers = Rack::Utils::HeaderHash.new(headers) if @need_resp
     if @wrap_body
       @reentrant = env['rack.multithread'] if @reentrant.nil?
-      @env, @status, @headers, @body = env, status, headers, body
-      return [ status, headers, @reentrant ? self.dup : self ]
+      wbody = @reentrant ? self.dup : self
+      wbody.env = env
+      wbody.status = status
+      wbody.headers = headers
+      wbody.body = body
+      wbody = Clogger::ToPath.new(wbody) if body.respond_to?(:to_path)
+      return [ status, headers, wbody ]
     end
     log(env, status, headers)
     [ status, headers, body ]
@@ -43,12 +51,13 @@ class Clogger
       @body_bytes_sent += Rack::Utils.bytesize(part)
       yield part
     end
-    ensure
-      log(@env, @status, @headers)
+    self
   end
 
   def close
     @body.close if @body.respond_to?(:close)
+    ensure
+      log(@env, @status, @headers)
   end
 
   def reentrant?
@@ -138,4 +147,16 @@ private
     }.join('')
   end
 
+  class ToPath
+    def to_path
+      rv = (body = clogger.body).to_path
+
+      # try to avoid unnecessary path lookups with to_io.stat instead of
+      # File.stat
+      clogger.body_bytes_sent =
+        (body.respond_to?(:to_io) ? body.to_io.stat : File.stat(rv)).size
+      rv
+    end
+  end
+
 end