clogger 0.0.5 → 0.0.6

data/.document

@@ -0,0 +1,4 @@
+README
+History
+lib
+ext/clogger_ext/clogger.c

data/.gitignore

@@ -11,3 +11,5 @@ Makefile
 /doc
 /local.mk
 /pkg
+/.manifest
+/History

data/GNUmakefile

@@ -1,5 +1,6 @@
 all:: test
 ruby = ruby
+rake = rake
 
 -include local.mk
 
@@ -7,10 +8,6 @@ ifeq ($(DLEXT),) # "so" for Linux
   DLEXT := $(shell $(ruby) -rrbconfig -e 'puts Config::CONFIG["DLEXT"]')
 endif
 
-ifeq ($(RUBY_VERSION),)
-  RUBY_VERSION := $(shell $(ruby) -e 'puts RUBY_VERSION')
-endif
-
 ext/clogger_ext/Makefile: ext/clogger_ext/clogger.c ext/clogger_ext/extconf.rb
 	cd ext/clogger_ext && $(ruby) extconf.rb
 
@@ -25,14 +22,17 @@ test-ext: ext/clogger_ext/clogger.$(DLEXT)
 	$(ruby) -Iext/clogger_ext:lib test/test_clogger.rb
 
 test-pure:
-	$(ruby) -Ilib test/test_clogger.rb
+	CLOGGER_PURE=t $(ruby) -Ilib test/test_clogger.rb
 
 test: test-ext test-pure
 
-Manifest.txt:
-	git ls-files > $@+
-	cmp $@+ $@ || mv $@+ $@
-	$(RM) $@+
+History:
+	$(rake) -s history > $@+
+	mv $@+ $@
+
+.manifest: History
+	(git ls-files; for i in $^ $@; do echo $$i; done) | LC_ALL=C sort > $@+
+	mv $@+ $@
 
 VERSION := $(shell git describe 2>/dev/null | sed 's/^v//')
 
@@ -41,6 +41,8 @@ v := /^v$(VERSION)$$/
 vPREV := $(shell git tag -l 2>/dev/null | sed -n -e '$(v)!h' -e '$(v){x;p;q}')
 release_notes := release_notes-$(VERSION).txt
 release_changes := release_changes-$(VERSION).txt
+release-notes: $(release_notes)
+release-changes: $(release_changes)
 $(release_changes): verify
 	git diff --stat $(vPREV) v$(VERSION) > $@+
 	echo >> $@+
@@ -55,24 +57,46 @@ verify:
 	@test -n "$(VERSION)" || { echo >&2 VERSION= not defined; exit 1; }
 	git rev-parse --verify refs/tags/v$(VERSION)^{}
 	@test -n "$(VISUAL)" || { echo >&2 VISUAL= not defined; exit 1; }
-
-package: verify
 	git diff-index --quiet HEAD^0
 	test `git rev-parse --verify HEAD^0` = \
 	     `git rev-parse --verify refs/tags/v$(VERSION)^{}`
-	$(RM) -r pkg
-	unset CLOGGER_EXT; rake package VERSION=$(VERSION)
-	CLOGGER_EXT=1 rake package VERSION=$(VERSION)
+
+pkg/clogger-$(VERSION).gem: .manifest History clogger.gemspec
+	gem build clogger.gemspec
+	mkdir -p pkg
+	mv $(@F) $@
+
+pkg/clogger-$(VERSION).tgz: HEAD = v$(VERSION)
+pkg/clogger-$(VERSION).tgz: .manifest History
+	$(RM) -r $(basename $@)
+	git archive --format=tar --prefix=$(basename $@)/ $(HEAD) | tar xv
+	install -m644 $^ $(basename $@)
+	cd pkg && tar cv $(basename $(@F)) | gzip -9 > $(@F)+
+	mv $@+ $@
+
+package: pkg/clogger-$(VERSION).gem pkg/clogger-$(VERSION).tgz
 
 # not using Hoe's release system since we release 2 gems but only one tgz
-release: package Manifest.txt $(release_notes) $(release_changes)
+release: package $(release_notes) $(release_changes)
 	rubyforge add_release -f -n $(release_notes) -a $(release_changes) \
 	  clogger clogger $(VERSION) pkg/clogger-$(VERSION).gem
 	rubyforge add_file \
 	  clogger clogger $(VERSION) pkg/clogger-$(VERSION).tgz
-	rubyforge add_release -f -n $(release_notes) -a $(release_changes) \
-	  clogger clogger_ext $(VERSION) pkg/clogger_ext-$(VERSION).gem
-	rake post_news
 endif
 
-.PHONY: test doc Manifest.txt release
+doc: .document History
+	rdoc -Na -t "$(shell sed -ne '1s/^= //p' README)"
+	install -m644 COPYING doc/COPYING
+	cd doc && ln README.html tmp.html && mv tmp.html index.html
+
+# publishes docs to http://clogger.rubyforge.org/
+# this preserves timestamps as best as possible to help HTTP caches out
+# git set-file-times can is here: http://git-scm.org/gitwiki/ExampleScripts
+publish_doc:
+	git set-file-times
+	$(RM) -r doc
+	$(MAKE) doc
+	rsync -av --delete doc/ rubyforge.org:/var/www/gforge-projects/clogger/
+	git ls-files | xargs touch
+
+.PHONY: test doc .manifest release History

data/{README.txt → README}

@@ -1,8 +1,5 @@
 = Clogger - configurable request logging for Rack
 
-* http://clogger.rubyforge.org/
-* mailto:clogger@librelist.com
-
 == DESCRIPTION
 
 Clogger is Rack middleware for logging HTTP requests.  The log format
@@ -23,6 +20,10 @@ is customizable so you can specify exactly which fields to log.
     " (double quote)
     all bytes in the range of \x00-\x1F
 
+* multi-instance capable and reentrant.  You can use Clogger in a
+  multi-threaded server, and even multiple Cloggers logging to
+  different locations and different formats in the same process.
+
 == SYNOPSIS
 
 Clogger may be loaded as Rack middleware in your config.ru:
@@ -104,24 +105,28 @@ requests) go to the mailing list.
 
 Do not send HTML mail or attachments.  Do not top post.
 
+Homepage: http://clogger.rubyforge.org/
+
 == INSTALL
 
 For all Rubygems users:
 
   gem install clogger
 
-If you're using MRI 1.8/1.9 and have a build environment, you can also try:
-
-  gem install clogger_ext
-
 If you do not use Rubygems, you may also use setup.rb from tarballs from
 the Rubyforge project page:
 
 * http://rubyforge.org/frs/?group_id=8896
 
+There is an optional C extension that should be compatible with MRI
+1.8/1.9.  The extensions should automatically be disabled for users of
+other Ruby implementations, but be sure to let us know if that's not the
+case.  No pre-built currently distributed, let us know if you're
+interested in helping with the release/support effort.
+
 == LICENSE
 
-Copyright (C) 2009 Eric Wong <normalperson@yhbt.net> and contributors.
+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
@@ -130,7 +135,7 @@ 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 for more details.
+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.,

data/Rakefile

@@ -1,6 +1,3 @@
-require 'hoe'
-$LOAD_PATH << 'lib'
-require 'clogger'
 begin
   require 'rake/extensiontask'
   Rake::ExtensionTask.new('clogger_ext')
@@ -8,23 +5,33 @@ rescue LoadError
   warn "rake-compiler not available, cross compiling disabled"
 end
 
-common = lambda do |hoe|
-  title = hoe.paragraphs_of("README.txt", 0).first.sub(/^= /, '')
-  hoe.version = Clogger::VERSION
-  hoe.summary = title.split(/\s*-\s*/, 2).last
-  hoe.description = hoe.paragraphs_of("README.txt", 3)
-  hoe.rubyforge_name = 'clogger'
-  hoe.author = 'Eric Wong'
-  hoe.email = 'clogger@librelist.com'
-  hoe.spec_extras.merge!('rdoc_options' => [ "--title", title ])
-  hoe.remote_rdoc_dir = ''
+desc 'prints RDoc-formatted history'
+task :history do
+  tags = `git tag -l`.split(/\n/).grep(/^v/).reverse
+  timefmt = '%Y-%m-%d %H:%M UTC'
+  tags.each do |tag|
+    header, subject, body = `git cat-file tag #{tag}`.split(/\n\n/)
+    tagger = header.split(/\n/).grep(/^tagger /).first.split(/\s/)
+    time = Time.at(tagger[-2].to_i).utc
+    puts "=== #{tag.sub(/^v/, '')} / #{time.strftime(timefmt)}"
+    puts ""
+    puts body
+    puts ""
+  end
 end
 
-if ENV['CLOGGER_EXT']
-  Hoe.spec('clogger_ext') do
-    common.call(self)
-    self.spec_extras.merge!(:extensions => Dir.glob('ext/*/extconf.rb'))
-  end
-else
-  Hoe.spec('clogger') { common.call(self) }
+desc "read news article from STDIN and post to rubyforge"
+task :publish_news do
+  require 'rubyforge'
+  IO.select([STDIN], nil, nil, 1) or abort "E: news must be read from stdin"
+  msg = STDIN.readlines
+  subject = msg.shift
+  blank = msg.shift
+  blank == "\n" or abort "no newline after subject!"
+  subject.strip!
+  body = msg.join("").strip!
+
+  rf = RubyForge.new.configure
+  rf.login
+  rf.post_news('clogger', subject, body)
 end

data/clogger.gemspec

@@ -0,0 +1,32 @@
+ENV["VERSION"] or abort "VERSION= must be specified"
+
+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.authors = ["Eric Wong"]
+  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.email = %q{clogger@librelist.com}
+  s.extra_rdoc_files = %w(README History)
+  s.files = File.readlines('.manifest').map! { |x| x.chomp! }
+  s.rdoc_options = [ "-Na",
+                     "-t", "Clogger - configurable request logging for Rack"
+                   ]
+  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)
+
+  # HeaderHash wasn't case-insensitive in old versions
+  s.add_dependency(%q<rack>, ["> 0.9"])
+  s.extensions = %w(ext/clogger_ext/extconf.rb)
+
+end

data/ext/clogger_ext/clogger.c

@@ -67,7 +67,9 @@ struct clogger {
 
 	VALUE env;
 	VALUE cookies;
-	VALUE response;
+	VALUE status;
+	VALUE headers;
+	VALUE body;
 
 	off_t body_bytes_sent;
 	struct timeval tv_start;
@@ -85,8 +87,11 @@ static ID close_id;
 static ID to_i_id;
 static ID to_s_id;
 static ID size_id;
+static ID sq_brace_id;
+static ID new_id;
 static VALUE cClogger;
 static VALUE mFormat;
+static VALUE cHeaderHash;
 
 /* common hash lookup keys */
 static VALUE g_HTTP_X_FORWARDED_FOR;
@@ -104,7 +109,6 @@ static VALUE g_empty;
 static VALUE g_space;
 static VALUE g_question_mark;
 static VALUE g_rack_request_cookie_hash;
-static VALUE g_bad_app_response;
 
 #define LOG_BUF_INIT_SIZE 128
 
@@ -160,99 +164,6 @@ static VALUE byte_xs(VALUE from)
 	return rv;
 }
 
-/* strcasecmp isn't locale independent, so we roll our own */
-static int str_case_eq(VALUE a, VALUE b)
-{
-	long alen = RSTRING_LEN(a);
-	long blen = RSTRING_LEN(b);
-
-	if (alen == blen) {
-		const char *aptr = RSTRING_PTR(a);
-		const char *bptr = RSTRING_PTR(b);
-
-		for (; alen--; ++aptr, ++bptr) {
-			if ((*bptr == *aptr)
-			    || (*aptr >= 'A' && *aptr <= 'Z' &&
-			        (*aptr | 0x20) == *bptr))
-				continue;
-			return 0;
-		}
-		return 1;
-	}
-	return 0;
-}
-
-struct response_ops { long nr; VALUE ops; };
-
-/* this can be worse than O(M*N) :<... but C loops are fast ... */
-static VALUE swap_sent_headers_unsafe(VALUE kv, VALUE memo)
-{
-	struct response_ops *tmp = (struct response_ops *)memo;
-	VALUE key = rb_obj_as_string(RARRAY_PTR(kv)[0]);
-	long i = RARRAY_LEN(tmp->ops);
-	VALUE *ary = RARRAY_PTR(tmp->ops);
-	VALUE value;
-
-	for (; --i >= 0; ary++) {
-		VALUE *op = RARRAY_PTR(*ary);
-		enum clogger_opcode opcode = NUM2INT(op[0]);
-
-		if (opcode != CL_OP_RESPONSE)
-			continue;
-		assert(RARRAY_LEN(*ary) == 2);
-		if (!str_case_eq(key, op[1]))
-			continue;
-
-		value = RARRAY_PTR(kv)[1];
-		op[0] = INT2NUM(CL_OP_LITERAL);
-		op[1] = byte_xs(rb_obj_as_string(value));
-
-		if (!--tmp->nr)
-			rb_iter_break();
-		return Qnil;
-	}
-	return Qnil;
-}
-
-static VALUE swap_sent_headers(VALUE kv, VALUE memo)
-{
-	if (TYPE(kv) != T_ARRAY)
-		rb_raise(rb_eTypeError, "headers not returning pairs");
-	if (RARRAY_LEN(kv) < 2)
-		rb_raise(rb_eTypeError, "headers not returning pairs");
-	return swap_sent_headers_unsafe(kv, memo);
-}
-
-static VALUE sent_headers_ops(struct clogger *c)
-{
-	struct response_ops tmp;
-	long i, len;
-	VALUE *ary;
-
-	if (!c->need_resp)
-		return c->fmt_ops;
-
-	tmp.nr = 0;
-	tmp.ops = rb_ary_dup(c->fmt_ops);
-	len = RARRAY_LEN(tmp.ops);
-	ary = RARRAY_PTR(tmp.ops);
-
-	for (i = 0; i < len; ++i) {
-		VALUE *op = RARRAY_PTR(ary[i]);
-
-		if (NUM2INT(op[0]) == CL_OP_RESPONSE) {
-			assert(RARRAY_LEN(ary[i]) == 2);
-			ary[i] = rb_ary_dup(ary[i]);
-			++tmp.nr;
-		}
-	}
-
-	rb_iterate(rb_each, RARRAY_PTR(c->response)[1],
-	           swap_sent_headers, (VALUE)&tmp);
-
-	return tmp.ops;
-}
-
 static void clogger_mark(void *ptr)
 {
 	struct clogger *c = ptr;
@@ -263,7 +174,9 @@ static void clogger_mark(void *ptr)
 	rb_gc_mark(c->log_buf);
 	rb_gc_mark(c->env);
 	rb_gc_mark(c->cookies);
-	rb_gc_mark(c->response);
+	rb_gc_mark(c->status);
+	rb_gc_mark(c->headers);
+	rb_gc_mark(c->body);
 }
 
 static VALUE clogger_alloc(VALUE klass)
@@ -287,6 +200,11 @@ 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)
 {
@@ -350,7 +268,7 @@ static void append_status(struct clogger *c)
 {
 	char buf[sizeof("999")];
 	int nr;
-	VALUE status = RARRAY_PTR(c->response)[0];
+	VALUE status = c->status;
 
 	if (TYPE(status) != T_FIXNUM) {
 		status = rb_funcall(status, to_i_id, 0);
@@ -545,6 +463,17 @@ static void append_request_env(struct clogger *c, VALUE key)
 	rb_str_buf_append(c->log_buf, tmp);
 }
 
+static void append_response(struct clogger *c, VALUE key)
+{
+	VALUE v;
+
+	assert(rb_obj_class(c->headers) == cHeaderHash);
+
+	v = rb_funcall(c->headers, sq_brace_id, 1, key);
+	v = NIL_P(v) ? g_dash : byte_xs(rb_obj_as_string(v));
+	rb_str_buf_append(c->log_buf, v);
+}
+
 static void special_var(struct clogger *c, enum clogger_special var)
 {
 	switch (var) {
@@ -579,7 +508,7 @@ static void special_var(struct clogger *c, enum clogger_special var)
 
 static VALUE cwrite(struct clogger *c)
 {
-	const VALUE ops = sent_headers_ops(c);
+	const VALUE ops = c->fmt_ops;
 	const VALUE *ary = RARRAY_PTR(ops);
 	long i = RARRAY_LEN(ops);
 	VALUE dst = c->log_buf;
@@ -598,8 +527,7 @@ static VALUE cwrite(struct clogger *c)
 			append_request_env(c, op[1]);
 			break;
 		case CL_OP_RESPONSE:
-			/* headers we found already got swapped for literals */
-			rb_str_buf_append(dst, g_dash);
+			append_response(c, op[1]);
 			break;
 		case CL_OP_SPECIAL:
 			special_var(c, NUM2INT(op[1]));
@@ -658,8 +586,10 @@ static VALUE clogger_init(int argc, VALUE *argv, VALUE self)
 		VALUE tmp;
 
 		c->logger = rb_hash_aref(o, ID2SYM(rb_intern("logger")));
-		if (!NIL_P(c->logger))
+		if (!NIL_P(c->logger)) {
+			rb_rescue(obj_enable_sync, c->logger, 0, 0);
 			c->fd = raw_fd(rb_rescue(obj_fileno, c->logger, 0, 0));
+		}
 
 		tmp = rb_hash_aref(o, ID2SYM(rb_intern("format")));
 		if (!NIL_P(tmp))
@@ -667,7 +597,7 @@ static VALUE clogger_init(int argc, VALUE *argv, VALUE self)
 	}
 
 	init_buffers(c);
-	c->fmt_ops = rb_funcall(self, rb_intern("compile_format"), 1, fmt);
+	c->fmt_ops = rb_funcall(self, rb_intern("compile_format"), 2, fmt, o);
 
 	if (Qtrue == rb_funcall(self, rb_intern("need_response_headers?"),
 	                        1, c->fmt_ops))
@@ -691,12 +621,10 @@ static VALUE body_iter_i(VALUE str, VALUE memop)
 
 static VALUE wrap_each(struct clogger *c)
 {
-	VALUE body = RARRAY_PTR(c->response)[2];
-
 	c->body_bytes_sent = 0;
-	rb_iterate(rb_each, body, body_iter_i, (VALUE)&c->body_bytes_sent);
+	rb_iterate(rb_each, c->body, body_iter_i, (VALUE)&c->body_bytes_sent);
 
-	return body;
+	return c->body;
 }
 
 /**
@@ -728,7 +656,7 @@ static VALUE clogger_close(VALUE self)
 {
 	struct clogger *c = clogger_get(self);
 
-	return rb_funcall(RARRAY_PTR(c->response)[2], close_id, 0);
+	return rb_funcall(c->body, close_id, 0);
 }
 
 /* :nodoc: */
@@ -739,7 +667,7 @@ static VALUE clogger_fileno(VALUE self)
 	return c->fd < 0 ? Qnil : INT2NUM(c->fd);
 }
 
-static void ccall(struct clogger *c, VALUE env)
+static VALUE ccall(struct clogger *c, VALUE env)
 {
 	VALUE rv;
 
@@ -748,14 +676,28 @@ static void ccall(struct clogger *c, VALUE env)
 	c->cookies = Qfalse;
 	rv = rb_funcall(c->app, call_id, 1, env);
 	if (TYPE(rv) == T_ARRAY && RARRAY_LEN(rv) == 3) {
-		c->response = rv;
+		VALUE *tmp = RARRAY_PTR(rv);
+
+		c->status = tmp[0];
+		c->headers = tmp[1];
+		c->body = tmp[2];
+
+		if (c->need_resp && cHeaderHash != rb_obj_class(c->headers)) {
+			c->headers = rb_funcall(cHeaderHash, new_id, 1, tmp[1]);
+			if (OBJ_FROZEN(rv))
+				rv = rb_ary_dup(rv);
+			rb_ary_store(rv, 1, c->headers);
+		}
 	} else {
-		c->response = g_bad_app_response;
+		c->status = INT2NUM(500);
+		c->headers = c->body = rb_ary_new();
 		cwrite(c);
 		rb_raise(rb_eTypeError,
 		         "app response not a 3 element Array: %s",
 			 RSTRING_PTR(rb_inspect(rv)));
 	}
+
+	return rv;
 }
 
 /*
@@ -768,12 +710,11 @@ static void ccall(struct clogger *c, VALUE env)
 static VALUE clogger_call(VALUE self, VALUE env)
 {
 	struct clogger *c = clogger_get(self);
+	VALUE rv;
 
 	if (c->wrap_body) {
-		VALUE tmp;
-
 		if (c->reentrant < 0) {
-			tmp = rb_hash_aref(env, g_rack_multithread);
+			VALUE tmp = rb_hash_aref(env, g_rack_multithread);
 			c->reentrant = Qfalse == tmp ? 0 : 1;
 		}
 		if (c->reentrant) {
@@ -781,16 +722,18 @@ static VALUE clogger_call(VALUE self, VALUE env)
 			c = clogger_get(self);
 		}
 
-		ccall(c, env);
-		tmp = rb_ary_dup(c->response);
-		rb_ary_store(tmp, 2, self);
-		return tmp;
+		rv = ccall(c, env);
+		if (OBJ_FROZEN(rv))
+			rv = rb_ary_dup(rv);
+		rb_ary_store(rv, 2, self);
+
+		return rv;
 	}
 
-	ccall(c, env);
+	rv = ccall(c, env);
 	cwrite(c);
 
-	return c->response;
+	return rv;
 }
 
 /* :nodoc */
@@ -812,14 +755,17 @@ static VALUE clogger_init_copy(VALUE clone, VALUE orig)
 
 #define CONST_GLOBAL_STR(val) CONST_GLOBAL_STR2(val, #val)
 
-static void init_bad_response(void)
+static void init_rack_utils_header_hash(void)
 {
-	g_bad_app_response = rb_ary_new();
-	rb_ary_store(g_bad_app_response, 0, INT2NUM(500));
-	rb_ary_store(g_bad_app_response, 1, rb_obj_freeze(rb_hash_new()));
-	rb_ary_store(g_bad_app_response, 2, rb_obj_freeze(rb_ary_new()));
-	rb_obj_freeze(g_bad_app_response);
-	rb_global_variable(&g_bad_app_response);
+	VALUE mRack, mUtils;
+#if 0
+  extra double quotes below are to disable rdoc (and so is avoiding comments)
+  let me know if there is a better way...
+#endif
+	rb_require("rack");
+	mRack = rb_define_module("Rack""");
+	mUtils = rb_define_module_under(mRack, "Utils""");
+	cHeaderHash = rb_define_class_under(mUtils, "HeaderHash""", rb_cHash);
 }
 
 void Init_clogger_ext(void)
@@ -831,6 +777,8 @@ void Init_clogger_ext(void)
 	to_i_id = rb_intern("to_i");
 	to_s_id = rb_intern("to_s");
 	size_id = rb_intern("size");
+	sq_brace_id = rb_intern("[]");
+	new_id = rb_intern("new");
 	cClogger = rb_define_class("Clogger", rb_cObject);
 	mFormat = rb_define_module_under(cClogger, "Format");
 	rb_define_alloc_func(cClogger, clogger_alloc);
@@ -857,5 +805,5 @@ void Init_clogger_ext(void)
 	CONST_GLOBAL_STR2(space, " ");
 	CONST_GLOBAL_STR2(question_mark, "?");
 	CONST_GLOBAL_STR2(rack_request_cookie_hash, "rack.request.cookie_hash");
-	init_bad_response();
+	init_rack_utils_header_hash();
 }

data/ext/clogger_ext/extconf.rb

@@ -1,12 +1,34 @@
-require 'mkmf'
+begin
+  require 'mkmf'
 
-if have_header('fcntl.h')
-  have_macro('F_GETFL', %w(fcntl.h))
-  have_macro('O_NONBLOCK', %w(unistd.h fcntl.h))
-end
+  # XXX let me know if this works for you...
+  if ! defined?(RUBY_VERSION) || RUBY_VERSION !~ /\A1\.[89]\./
+    raise "Invalid RUBY_VERSION for C extension"
+  end
+
+  have_header('ruby.h') or raise "ruby.h header not found!"
+
+  if have_header('fcntl.h')
+    have_macro('F_GETFL', %w(fcntl.h))
+    have_macro('O_NONBLOCK', %w(unistd.h fcntl.h))
+  end
 
-have_func('localtime_r', 'time.h') or abort "localtime_r needed"
-have_func('gmtime_r', 'time.h') or abort "gmtime_r needed"
-have_func('rb_str_set_len', 'ruby.h')
-dir_config('clogger_ext')
-create_makefile('clogger_ext')
+  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')
+  dir_config('clogger_ext')
+  create_makefile('clogger_ext')
+rescue Object => err
+  warn "E: #{err.inspect}"
+  warn "Skipping C extension, pure Ruby version will be used instead"
+
+  # generate a dummy Makefile to fool rubygems installer
+  targets = %w(all static clean distclean realclean
+               install install-so install-rb install-rb-default
+               pre-install-rb pre-install-rb-default
+               site-install site-install-so site-install-rb)
+  File.open(File.dirname(__FILE__) << "/Makefile", "wb") do |fp|
+    fp.puts targets.join(' ') << ":"
+    fp.puts "\techo >&2 extension disabled"
+  end
+end

data/lib/clogger.rb

@@ -1,6 +1,6 @@
 # -*- encoding: binary -*-
 class Clogger
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 
   OP_LITERAL = 0
   OP_REQUEST = 1
@@ -40,7 +40,9 @@ private
       %w(request_method content_length content_type
          remote_addr remote_ident remote_user
          path_info query_string script_name
-         server_name server_port).join('|') << ')\z').freeze
+         server_name server_port
+         auth_type gateway_interface server_software path_translated
+         ).join('|') << ')\z').freeze
 
   SCAN = /([^$]*)(\$+(?:env\{\w+(?:\.[\w\.]+)?\}|
                         e\{[^\}]+\}|
@@ -48,8 +50,9 @@ private
                         time_(?:utc|local)\{[^\}]+\}|
                         \w*))?([^$]*)/x
 
-  def compile_format(str)
+  def compile_format(str, opt = {})
     rv = []
+    opt ||= {}
     str.scan(SCAN).each do |pre,tok,post|
       rv << [ OP_LITERAL, pre ] if pre && pre != ""
 
@@ -97,8 +100,9 @@ private
     # auto-append a newline
     last = rv.last or return rv
     op = last.first
-    if (op == OP_LITERAL && /\n\z/ !~ last.last) || op != OP_LITERAL
-      rv << [ OP_LITERAL, "\n" ]
+    ors = opt[:ORS] || "\n"
+    if (op == OP_LITERAL && /#{ors}\z/ !~ last.last) || op != OP_LITERAL
+      rv << [ OP_LITERAL, ors ] if ors.size > 0
     end
 
     rv
@@ -131,6 +135,7 @@ end
 require 'clogger/format'
 
 begin
+  raise LoadError if ENV['CLOGGER_PURE']
   require 'clogger_ext'
 rescue LoadError
   require 'clogger/pure'

data/lib/clogger/pure.rb

@@ -1,6 +1,8 @@
 # -*- encoding: binary -*-
 # :stopdoc:
-#
+
+require 'rack'
+
 # Not at all optimized for performance, this was written based on
 # the original C extension code so it's not very Ruby-ish...
 class Clogger
@@ -8,9 +10,11 @@ class Clogger
   def initialize(app, opts = {})
     @app = app
     @logger = opts[:logger]
-    @fmt_ops = compile_format(opts[:format] || Format::Common)
+    (@logger.sync = true) rescue nil
+    @fmt_ops = compile_format(opts[:format] || Format::Common, opts)
     @wrap_body = need_wrap_body?(@fmt_ops)
     @reentrant = nil
+    @need_resp = need_response_headers?(@fmt_ops)
     @body_bytes_sent = 0
   end
 
@@ -22,6 +26,7 @@ class Clogger
       raise TypeError, "app response not a 3 element Array: #{resp.inspect}"
     end
     status, headers, body = resp
+    headers = Rack::Utils::HeaderHash.new(headers) if @need_resp
     if wrap_body?
       @reentrant = env['rack.multithread']
       @env, @status, @headers, @body = env, status, headers, body
@@ -113,7 +118,7 @@ private
       case op[0]
       when OP_LITERAL; op[1]
       when OP_REQUEST; byte_xs(env[op[1]] || "-")
-      when OP_RESPONSE; byte_xs(get_sent_header(headers, op[1]))
+      when OP_RESPONSE; byte_xs(headers[op[1]] || "-")
       when OP_SPECIAL; special_var(op[1], env, status, headers)
       when OP_EVAL; eval(op[1]).to_s rescue "-"
       when OP_TIME_LOCAL; Time.now.strftime(op[1])
@@ -132,14 +137,4 @@ private
     }.join('')
   end
 
-  def get_sent_header(headers, match)
-    headers.each do |pair|
-      Array === pair && pair.size >= 2 or
-        raise TypeError, "headers not returning pairs"
-      key, value = pair
-      match == key.downcase and return value
-    end
-    "-"
-  end
-
 end

data/test/test_clogger.rb

@@ -389,7 +389,7 @@ class TestClogger < Test::Unit::TestCase
     str = StringIO.new
     app = lambda { |env| [302, [ %w(a) ], []] }
     cl = Clogger.new(app, :logger => str, :format => '$sent_http_set_cookie')
-    assert_raise(TypeError) { cl.call(@req) }
+    assert_nothing_raised { cl.call(@req) }
   end
 
   def test_http_09_request
@@ -434,4 +434,39 @@ class TestClogger < Test::Unit::TestCase
     assert_equal "text/plain\n", str.string
   end
 
+  def test_clogger_synced
+    io = StringIO.new
+    logger = Struct.new(:sync, :io).new(false, io)
+    assert ! logger.sync
+    def logger.<<(str)
+      io << str
+    end
+    app = lambda { |env| [302, [ %w(a) ], []] }
+    cl = Clogger.new(app, :logger => logger)
+    assert logger.sync
+  end
+
+  def test_clogger_unsyncable
+    logger = ''
+    assert ! logger.respond_to?('sync=')
+    app = lambda { |env| [302, [ %w(a) ], []] }
+    assert_nothing_raised { Clogger.new(app, :logger => logger) }
+  end
+
+  def test_clogger_no_ORS
+    s = ''
+    app = lambda { |env| [302, [ %w(a) ], []] }
+    cl = Clogger.new(app, :logger => s, :format => "$request", :ORS => "")
+    cl.call(@req)
+    assert_equal "GET /hello?goodbye=true HTTP/1.0", s
+  end
+
+  def test_clogger_weird_ORS
+    s = ''
+    app = lambda { |env| [302, [ %w(a) ], []] }
+    cl = Clogger.new(app, :logger => s, :format => "<$request", :ORS => ">")
+    cl.call(@req)
+    assert_equal "<GET /hello?goodbye=true HTTP/1.0>", s
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: clogger
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Eric Wong
@@ -9,18 +9,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-02 00:00:00 -07:00
+date: 2009-09-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: hoe
-  type: :development
+  name: rack
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version 
-        version: 2.3.3
+        version: "0.9"
     version: 
 description: |-
   Clogger is Rack middleware for logging HTTP requests.  The log format
@@ -28,20 +28,21 @@ description: |-
 email: clogger@librelist.com
 executables: []
 
-extensions: []
-
+extensions: 
+- ext/clogger_ext/extconf.rb
 extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- README.txt
+- README
+- History
 files: 
+- .document
 - .gitignore
+- .manifest
 - COPYING
 - GNUmakefile
-- History.txt
-- Manifest.txt
-- README.txt
+- History
+- README
 - Rakefile
+- clogger.gemspec
 - ext/clogger_ext/clogger.c
 - ext/clogger_ext/extconf.rb
 - ext/clogger_ext/ruby_1_9_compat.h
@@ -56,7 +57,8 @@ licenses: []
 
 post_install_message: 
 rdoc_options: 
-- --title
+- -Na
+- -t
 - Clogger - configurable request logging for Rack
 require_paths: 
 - lib

data/History.txt

@@ -1,45 +0,0 @@
-=== 0.0.5 / 2009-09-02
-
-   The following variables are now exposed: $request_method,
-   $content_length and $content_type.  Additionally, attempts
-   to use $http_content_length or $http_content_type will be
-   remapped to use the non-"$http_"-prefixed variable instead
-   since the "$http_"-variants of those variables is not allowed
-   by Rack.
-
-=== 0.0.4 / 2009-09-02
-
-    The pure Ruby version now escapes with uppercase A-F
-    characters to match nginx log output.  There are now extra
-    checks against badly behaving Rack applications and 500
-    errors will be logged before TypeError is raised if the
-    application response does not conform (minimally) to Rack
-    expectations.  Finally, handling of $request (requests
-    without "HTTP_VERSION" set in the Rack env) should now be
-    logged correctly without unnecessary trailing characters.
-
-    Hackers: the primary git repository has been moved to
-    git://git.bogomips.org/clogger.git for now since I'm having
-    issues with pushing to Rubyforge (seems related to Support
-    Requests item #26185).
-
-=== 0.0.3 / 2009-08-29
-
-    The MRI extension clogger_ext gets GC bug fix and
-    cleanups/robustness improvements.  It should now be more
-    tolerant of misbehaving applications in that it'll be less
-    likely to segfault.  No changes to the (recommended) pure
-    implementation.
-
-=== 0.0.2 / 2009-08-29
-
-* 2 bug fixes
-
-   * support "$request_uri" as a log variable
-   * Log bad/invalid app responses as 500 errors
-
-=== 0.0.1 / 2009-08-28
-
-* 1 major enhancement
-
-  * initial release

data/Manifest.txt

@@ -1,15 +0,0 @@
-.gitignore
-COPYING
-GNUmakefile
-History.txt
-Manifest.txt
-README.txt
-Rakefile
-ext/clogger_ext/clogger.c
-ext/clogger_ext/extconf.rb
-ext/clogger_ext/ruby_1_9_compat.h
-lib/clogger.rb
-lib/clogger/format.rb
-lib/clogger/pure.rb
-setup.rb
-test/test_clogger.rb