clogger 0.6.0 → 0.7.0

data/GIT-VERSION-GEN

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

data/GNUmakefile

@@ -133,6 +133,7 @@ release: verify package $(release_notes) $(release_changes)
 	gem push $(pkggem)
 	rubyforge add_file \
 	  $(rfproject) $(rfpackage) $(VERSION) $(pkggem)
+	$(RAKE) publish_news VERSION=$(VERSION)
 else
 gem install-gem: GIT-VERSION-FILE
 	$(MAKE) $@ VERSION=$(GIT_VERSION)

data/README

@@ -1,7 +1,5 @@
 = \Clogger - configurable request logging for Rack
 
-== DESCRIPTION
-
 \Clogger is Rack middleware for logging HTTP requests.  The log format
 is customizable so you can specify exactly which fields to log.
 
@@ -26,7 +24,7 @@ is customizable so you can specify exactly which fields to log.
 
 * 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.
+  and supported under MRI 1.8.7, 1.9.1, 1.9.2 and Rubinius.
 
 == SYNOPSIS
 

data/Rakefile

@@ -5,11 +5,27 @@ rescue LoadError
   warn "rake-compiler not available, cross compiling disabled"
 end
 
-desc "read news article from STDIN and post to rubyforge"
+cgit_url = "http://git.bogomips.org/cgit/clogger.git"
+git_url = 'git://git.bogomips.org/clogger.git'
+
+desc "post news article 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
+  spec = Gem::Specification.load('clogger.gemspec')
+  tmp = Tempfile.new('rf-news')
+  _, subject, body = `git cat-file tag v#{spec.version}`.split(/\n\n/, 3)
+  tmp.puts subject
+  tmp.puts
+  tmp.puts spec.description.strip
+  tmp.puts ""
+  tmp.puts "* #{spec.homepage}"
+  tmp.puts "* #{spec.email}"
+  tmp.puts "* #{git_url}"
+  tmp.print "\nChanges:\n\n"
+  tmp.puts body
+  tmp.flush
+  system(ENV["VISUAL"], tmp.path) or abort "#{ENV["VISUAL"]} failed: #$?"
+  msg = File.readlines(tmp.path)
   subject = msg.shift
   blank = msg.shift
   blank == "\n" or abort "no newline after subject!"
@@ -21,9 +37,6 @@ task :publish_news do
   rf.post_news('clogger', subject, body)
 end
 
-cgit_url = "http://git.bogomips.org/cgit/clogger.git"
-git_url = 'git://git.bogomips.org/clogger.git'
-
 desc "post to RAA"
 task :raa_update do
   require 'rubygems'

data/ext/clogger_ext/broken_system_compat.h

@@ -0,0 +1,36 @@
+/*
+ * this header includes functions to support broken systems
+ * without clock_gettime() or CLOCK_MONOTONIC
+ */
+
+#ifndef HAVE_TYPE_CLOCKID_T
+typedef int clockid_t;
+#endif
+
+#ifndef HAVE_CLOCK_GETTIME
+#  ifndef CLOCK_REALTIME
+#    define CLOCK_REALTIME 0 /* whatever */
+#  endif
+static int fake_clock_gettime(clockid_t clk_id, struct timespec *res)
+{
+	struct timeval tv;
+	int r = gettimeofday(&tv, NULL);
+
+	assert(0 == r && "gettimeofday() broke!?");
+	res->tv_sec = tv.tv_sec;
+	res->tv_nsec = tv.tv_usec * 1000;
+
+	return r;
+}
+#  define clock_gettime fake_clock_gettime
+#endif /* broken systems w/o clock_gettime() */
+
+/*
+ * UGH
+ * CLOCK_MONOTONIC is not guaranteed to be a macro, either
+ */
+#ifndef CLOCK_MONOTONIC
+#  if (!defined(_POSIX_MONOTONIC_CLOCK) || !defined(HAVE_CLOCK_MONOTONIC))
+#    define CLOCK_MONOTONIC CLOCK_REALTIME
+#  endif
+#endif

data/ext/clogger_ext/clogger.c

@@ -13,9 +13,39 @@
 #ifdef HAVE_FCNTL_H
 #  include <fcntl.h>
 #endif
-#define _POSIX_C_SOURCE 200112L
+#ifndef _POSIX_C_SOURCE
+#  define _POSIX_C_SOURCE 200112L
+#endif
 #include <time.h>
 #include "ruby_1_9_compat.h"
+#include "broken_system_compat.h"
+
+/*
+ * Availability of a monotonic clock needs to be detected at runtime
+ * since we could've been built on a different system than we're run
+ * under.
+ */
+static clockid_t hopefully_CLOCK_MONOTONIC;
+
+static void check_clock(void)
+{
+	struct timespec now;
+
+	hopefully_CLOCK_MONOTONIC = CLOCK_MONOTONIC;
+
+	/* we can't check this reliably at compile time */
+	if (clock_gettime(CLOCK_MONOTONIC, &now) == 0)
+		return;
+
+	if (clock_gettime(CLOCK_REALTIME, &now) == 0) {
+		hopefully_CLOCK_MONOTONIC = CLOCK_REALTIME;
+		rb_warn("CLOCK_MONOTONIC not available, "
+			"falling back to CLOCK_REALTIME");
+	}
+	rb_warn("clock_gettime() totally broken, " \
+	        "falling back to pure Ruby Clogger");
+	rb_raise(rb_eLoadError, "clock_gettime() broken");
+}
 
 static void clock_diff(struct timespec *a, const struct timespec *b)
 {
@@ -94,8 +124,8 @@ static ID sq_brace_id;
 static ID new_id;
 static ID to_path_id;
 static ID to_io_id;
+static ID respond_to_id;
 static VALUE cClogger;
-static VALUE cToPath;
 static VALUE mFormat;
 static VALUE cHeaderHash;
 
@@ -205,11 +235,6 @@ static struct clogger *clogger_get(VALUE self)
 	return c;
 }
 
-static VALUE obj_fileno(VALUE obj)
-{
-	return rb_funcall(obj, rb_intern("fileno"), 0);
-}
-
 /* only for writing to regular files, not stupid crap like NFS  */
 static void write_full(int fd, const void *buf, size_t count)
 {
@@ -350,11 +375,8 @@ static void append_ts(struct clogger *c, const VALUE *op, struct timespec *ts)
 static void append_request_time_fmt(struct clogger *c, const VALUE *op)
 {
 	struct timespec now;
-	int r = clock_gettime(CLOCK_MONOTONIC, &now);
-
-	if (unlikely(r != 0))
-		rb_sys_fail("clock_gettime(CLOCK_MONONTONIC)");
 
+	clock_gettime(hopefully_CLOCK_MONOTONIC, &now);
 	clock_diff(&now, &c->ts_start);
 	append_ts(c, op, &now);
 }
@@ -420,10 +442,11 @@ static void append_request_length(struct clogger *c)
 	}
 }
 
-static void append_time(struct clogger *c, enum clogger_opcode op, VALUE fmt)
+static void
+append_time(struct clogger *c, enum clogger_opcode op, VALUE fmt, VALUE buf)
 {
-	/* you'd have to be a moron to use formats this big... */
-	char buf[sizeof("Saturday, November 01, 1970, 00:00:00 PM +0000")];
+	char *buf_ptr = RSTRING_PTR(buf);
+	size_t buf_size = RSTRING_LEN(buf) + 1; /* "\0" */
 	size_t nr;
 	struct tm tmp;
 	time_t t = time(NULL);
@@ -435,11 +458,9 @@ static void append_time(struct clogger *c, enum clogger_opcode op, VALUE fmt)
 	else
 		assert(0 && "unknown op");
 
-	nr = strftime(buf, sizeof(buf), RSTRING_PTR(fmt), &tmp);
-	if (nr == 0 || nr == sizeof(buf))
-		rb_str_buf_append(c->log_buf, g_dash);
-	else
-		rb_str_buf_cat(c->log_buf, buf, nr);
+	nr = strftime(buf_ptr, buf_size, RSTRING_PTR(fmt), &tmp);
+	assert(nr < buf_size && "time format too small!");
+	rb_str_buf_cat(c->log_buf, buf_ptr, nr);
 }
 
 static void append_pid(struct clogger *c)
@@ -559,7 +580,7 @@ static VALUE cwrite(struct clogger *c)
 			break;
 		case CL_OP_TIME_LOCAL:
 		case CL_OP_TIME_UTC:
-			append_time(c, opcode, op[1]);
+			append_time(c, opcode, op[1], op[2]);
 			break;
 		case CL_OP_REQUEST_TIME:
 			append_request_time_fmt(c, op);
@@ -728,7 +749,7 @@ static VALUE ccall(struct clogger *c, VALUE env)
 {
 	VALUE rv;
 
-	clock_gettime(CLOCK_MONOTONIC, &c->ts_start);
+	clock_gettime(hopefully_CLOCK_MONOTONIC, &c->ts_start);
 	c->env = env;
 	c->cookies = Qfalse;
 	rv = rb_funcall(c->app, call_id, 1, env);
@@ -785,9 +806,6 @@ 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;
@@ -799,7 +817,24 @@ static VALUE clogger_call(VALUE self, VALUE env)
 	return rv;
 }
 
-/* :nodoc */
+static void duplicate_buffers(VALUE ops)
+{
+	long i = RARRAY_LEN(ops);
+	VALUE *ary = RARRAY_PTR(ops);
+
+	for ( ; --i >= 0; ary++) {
+		VALUE *op = RARRAY_PTR(*ary);
+		enum clogger_opcode opcode = FIX2INT(op[0]);
+
+		if (opcode == CL_OP_TIME_LOCAL || opcode == CL_OP_TIME_UTC) {
+			Check_Type(op[2], T_STRING);
+			op[2] = rb_str_dup(op[2]);
+			rb_str_modify(op[2]); /* trigger copy-on-write */
+		}
+	}
+}
+
+/* :nodoc: */
 static VALUE clogger_init_copy(VALUE clone, VALUE orig)
 {
 	struct clogger *a = clogger_get(orig);
@@ -807,6 +842,7 @@ static VALUE clogger_init_copy(VALUE clone, VALUE orig)
 
 	memcpy(b, a, sizeof(struct clogger));
 	init_buffers(b);
+	duplicate_buffers(b->fmt_ops);
 
 	return clone;
 }
@@ -818,25 +854,38 @@ 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
+/*
+ * call-seq:
+ *   clogger.respond_to?(:to_path) => true or false
+ *   clogger.respond_to?(:close)  => true
+ *
+ * used to delegate +:to_path+ checks for Rack webservers that optimize
+ * static file serving
+ */
+static VALUE respond_to(VALUE self, VALUE method)
+{
+	struct clogger *c = clogger_get(self);
+	ID id = rb_to_id(method);
+
+	if (close_id == id)
+		return Qtrue;
+	return rb_respond_to(c->body, id);
+}
 
+/*
+ * call-seq:
+ *   clogger.to_path
+ *
+ * used to proxy +:to_path+ method calls to the wrapped response body.
+ */
 static VALUE to_path(VALUE self)
 {
-	VALUE my_clogger = ToPath_clogger(self);
-	struct clogger *c = clogger_get(my_clogger);
+	struct clogger *c = clogger_get(self);
 	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);
+	const char *cpath = StringValuePtr(path);
 
 	/* try to avoid an extra path lookup  */
 	if (rb_respond_to(c->body, to_io_id))
@@ -863,6 +912,8 @@ void Init_clogger_ext(void)
 {
 	VALUE tmp;
 
+	check_clock();
+
 	ltlt_id = rb_intern("<<");
 	call_id = rb_intern("call");
 	each_id = rb_intern("each");
@@ -874,6 +925,7 @@ void Init_clogger_ext(void)
 	new_id = rb_intern("new");
 	to_path_id = rb_intern("to_path");
 	to_io_id = rb_intern("to_io");
+	respond_to_id = rb_intern("respond_to?");
 	cClogger = rb_define_class("Clogger", rb_cObject);
 	mFormat = rb_define_module_under(cClogger, "Format");
 	rb_define_alloc_func(cClogger, clogger_alloc);
@@ -885,6 +937,8 @@ void Init_clogger_ext(void)
 	rb_define_method(cClogger, "fileno", clogger_fileno, 0);
 	rb_define_method(cClogger, "wrap_body?", clogger_wrap_body, 0);
 	rb_define_method(cClogger, "reentrant?", clogger_reentrant, 0);
+	rb_define_method(cClogger, "to_path", to_path, 0);
+	rb_define_method(cClogger, "respond_to?", respond_to, 1);
 	CONST_GLOBAL_STR(REMOTE_ADDR);
 	CONST_GLOBAL_STR(HTTP_X_FORWARDED_FOR);
 	CONST_GLOBAL_STR(REQUEST_METHOD);
@@ -903,9 +957,4 @@ 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);
-#ifndef RSTRUCT_PTR
-	clogger_id = rb_intern("clogger");
-#endif
 }

data/ext/clogger_ext/extconf.rb

@@ -13,10 +13,12 @@ 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'
+  $CPPFLAGS += '-D_POSIX_C_SOURCE=200112L'
+  unless have_macro('CLOCK_MONOTONIC', 'time.h')
     have_func('CLOCK_MONOTONIC', 'time.h')
   end
+  have_type('clockid_t', 'time.h')
+  have_func('clock_gettime', 'time.h')
   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,14 +11,6 @@
 #ifndef RARRAY_LEN
 #  define RARRAY_LEN(s) (RARRAY(s)->len)
 #endif
-#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
 /* this is taken from Ruby 1.8.7, 1.8.6 may not have it */

data/lib/clogger.rb

@@ -4,8 +4,8 @@ require 'rack'
 # See the README for usage instructions
 class Clogger
 
-  # the version of Clogger, currently 0.6.0
-  VERSION = '0.6.0'
+  # the version of Clogger, currently 0.7.0
+  VERSION = '0.7.0'
 
   # :stopdoc:
   OP_LITERAL = 0
@@ -23,6 +23,7 @@ class Clogger
   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',
@@ -40,15 +41,6 @@ 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\$(' <<
@@ -66,6 +58,7 @@ private
                         \w*))?([^$]*)/x
 
   def compile_format(str, opt = {})
+    longest_day = Time.at(26265600) # "Saturday, November 01, 1970 00:00:00"
     rv = []
     opt ||= {}
     str.scan(SCAN).each do |pre,tok,post|
@@ -92,9 +85,11 @@ private
         when /\A\$sent_http_(\w+)\z/
           rv << [ OP_RESPONSE, $1.downcase.tr('_','-') ]
         when /\A\$time_local\{([^\}]+)\}\z/
-          rv << [ OP_TIME_LOCAL, $1 ]
+          fmt = $1
+          rv << [ OP_TIME_LOCAL, fmt, longest_day.strftime(fmt) ]
         when /\A\$time_utc\{([^\}]+)\}\z/
-          rv << [ OP_TIME_UTC, $1 ]
+          fmt = $1
+          rv << [ OP_TIME_UTC, fmt, longest_day.strftime(fmt) ]
         when /\A\$time\{(\d+)\}\z/
           rv << [ OP_TIME, *usec_conv_pair(tok, $1.to_i) ]
         when /\A\$request_time\{(\d+)\}\z/

data/lib/clogger/pure.rb

@@ -43,7 +43,6 @@ class Clogger
       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)
@@ -77,6 +76,19 @@ class Clogger
     @logger.respond_to?(:fileno) ? @logger.fileno : nil
   end
 
+  def respond_to?(m)
+    :close == m.to_sym || @body.respond_to?(m)
+  end
+
+  def to_path
+    rv = @body.to_path
+    # try to avoid unnecessary path lookups with to_io.stat instead of
+    # File.size
+    @body_bytes_sent =
+           @body.respond_to?(:to_io) ? @body.to_io.stat.size : File.size(rv)
+    rv
+  end
+
 private
 
   def byte_xs(s)
@@ -151,17 +163,4 @@ private
       end
     }.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

data/test/test_clogger.rb

@@ -156,12 +156,13 @@ 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' ],
+      [ Clogger::OP_TIME_LOCAL, '%d/%b/%Y:%H:%M:%S %z', longest_day ],
       [ Clogger::OP_LITERAL, "] \"" ],
       [ Clogger::OP_SPECIAL, Clogger::SPECIAL_VARS[:request] ],
       [ Clogger::OP_LITERAL, "\" "],
@@ -677,4 +678,23 @@ class TestClogger < Test::Unit::TestCase
     assert s[-1].to_f >= 0.100
     assert s[-1].to_f <= 0.110
   end
+
+  def test_insanely_long_time_format
+    s = []
+    app = lambda { |env| [200, [], [] ] }
+    fmt = '%Y' * 100
+    expect = Time.now.utc.strftime(fmt) << "\n"
+    assert_equal 100 * 4 + 1, expect.size
+    cl = Clogger.new(app, :logger => s, :format => "$time_utc{#{fmt}}")
+    status, headers, body = cl.call(@req)
+    assert_equal expect, s[0]
+  end
+
+  def test_time_utc
+    s = []
+    app = lambda { |env| [200, [], [] ] }
+    cl = Clogger.new(app, :logger => s, :format => "$time_utc")
+    status, headers, body = cl.call(@req)
+    assert %r!\A\d+/\w+/\d{4}:\d\d:\d\d:\d\d \+0000\n\z! =~ s[0], s.inspect
+  end
 end

data/test/test_clogger_to_path.rb

@@ -31,6 +31,14 @@ class TestCloggerToPath < Test::Unit::TestCase
     }
   end
 
+  def check_body(body)
+    assert body.respond_to?(:to_path)
+    assert body.respond_to?("to_path")
+
+    assert ! body.respond_to?(:to_Path)
+    assert ! body.respond_to?("to_Path")
+  end
+
   def test_wraps_to_path
     logger = StringIO.new
     tmp = Tempfile.new('')
@@ -49,7 +57,8 @@ class TestCloggerToPath < Test::Unit::TestCase
     end.to_app
 
     status, headers, body = app.call(@req)
-    assert_instance_of(Clogger::ToPath, body)
+    assert_instance_of(Clogger, body)
+    check_body(body)
     assert logger.string.empty?
     assert_equal tmp.path, body.to_path
     body.close
@@ -75,7 +84,8 @@ class TestCloggerToPath < Test::Unit::TestCase
     end.to_app
 
     status, headers, body = app.call(@req)
-    assert_instance_of(Clogger::ToPath, body)
+    assert_instance_of(Clogger, body)
+    check_body(body)
     assert logger.string.empty?
     assert_equal "/dev/fd/#{tmp.fileno}", body.to_path
     body.close
@@ -107,7 +117,9 @@ class TestCloggerToPath < Test::Unit::TestCase
     end.to_app
 
     status, headers, body = app.call(@req)
-    assert_instance_of(Clogger::ToPath, body)
+    assert_instance_of(Clogger, body)
+    check_body(body)
+
     body.to_path
     assert_kind_of IO, tmp.instance_variable_get(:@to_io_called)
     assert logger.string.empty?
@@ -132,6 +144,8 @@ class TestCloggerToPath < Test::Unit::TestCase
     end.to_app
     status, headers, body = app.call(@req)
     assert_instance_of(Clogger, body)
+    assert ! body.respond_to?(:to_path)
+    assert ! body.respond_to?("to_path")
     assert logger.string.empty?
     body.close
     assert ! logger.string.empty?

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: clogger
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 3
   prerelease: false
   segments: 
   - 0
-  - 6
+  - 7
   - 0
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - cloggers
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-25 00:00:00 +00:00
+date: 2011-01-15 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -48,7 +48,9 @@ dependencies:
         version: "1.0"
   type: :development
   version_requirements: *id002
-description: == DESCRIPTION
+description: |-
+  \Clogger is Rack middleware for logging HTTP requests.  The log format
+  is customizable so you can specify exactly which fields to log.
 email: clogger@librelist.com
 executables: []
 
@@ -80,6 +82,7 @@ files:
 - README
 - Rakefile
 - clogger.gemspec
+- ext/clogger_ext/broken_system_compat.h
 - ext/clogger_ext/clogger.c
 - ext/clogger_ext/extconf.rb
 - ext/clogger_ext/ruby_1_9_compat.h