clogger 0.3.2 → 0.4.0

data/GIT-VERSION-GEN

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

data/GNUmakefile

@@ -46,7 +46,7 @@ NEWS: GIT-VERSION-FILE .manifest
 	$(RAKE) -s news_rdoc > $@+
 	mv $@+ $@
 
-SINCE = 0.0.7
+SINCE = 0.3.2
 ChangeLog: log_range = $(shell test -n "$(SINCE)" && echo v$(SINCE)..)
 ChangeLog: GIT-VERSION-FILE
 	@echo "ChangeLog from $(GIT_URL) ($(SINCE)..$(GIT_VERSION))" > $@+

data/ext/clogger_ext/clogger.c

@@ -105,7 +105,6 @@ static VALUE g_rack_errors;
 static VALUE g_rack_input;
 static VALUE g_rack_multithread;
 static VALUE g_dash;
-static VALUE g_empty;
 static VALUE g_space;
 static VALUE g_question_mark;
 static VALUE g_rack_request_cookie_hash;
@@ -120,7 +119,7 @@ static void init_buffers(struct clogger *c)
 static inline int need_escape(unsigned c)
 {
 	assert(c <= 0xff);
-	return !!(c == '\'' || c == '"' || (c >= 0 && c <= 0x1f));
+	return !!(c == '\'' || c == '"' || c <= 0x1f);
 }
 
 /* we are encoding-agnostic, clients can send us all sorts of junk */
@@ -144,7 +143,7 @@ static VALUE byte_xs_str(VALUE from)
 	if (new_len == len)
 		return from;
 
-	rv = rb_str_new(0, new_len);
+	rv = rb_str_new(NULL, new_len);
 	new_ptr = (unsigned char *)RSTRING_PTR(rv);
 	ptr = (unsigned char *)RSTRING_PTR(from);
 	for (; --len >= 0; ptr++) {
@@ -214,15 +213,16 @@ static VALUE obj_enable_sync(VALUE obj)
 static void write_full(int fd, const void *buf, size_t count)
 {
 	ssize_t r;
+	unsigned long ubuf = (unsigned long)buf;
 
 	while (count > 0) {
-		r = write(fd, buf, count);
+		r = write(fd, (void *)ubuf, count);
 
-		if (r == count) { /* overwhelmingly likely */
+		if ((size_t)r == count) { /* overwhelmingly likely */
 			return;
 		} else if (r > 0) {
 			count -= r;
-			buf += r;
+			ubuf += r;
 		} else {
 			if (errno == EINTR || errno == EAGAIN)
 				continue; /* poor souls on NFS and like: */
@@ -237,15 +237,15 @@ 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 fileno)
+static int raw_fd(VALUE my_fileno)
 {
 #if defined(HAVE_FCNTL) && defined(F_GETFL) && defined(O_NONBLOCK)
 	int fd;
 	int flags;
 
-	if (NIL_P(fileno))
+	if (NIL_P(my_fileno))
 		return -1;
-	fd = NUM2INT(fileno);
+	fd = NUM2INT(my_fileno);
 
 	flags = fcntl(fd, F_GETFL);
 	if (flags < 0)
@@ -284,7 +284,7 @@ static void append_status(struct clogger *c)
 		}
 	}
 
-	nr = NUM2INT(status);
+	nr = FIX2INT(status);
 	if (nr >= 100 && nr <= 999) {
 		nr = snprintf(buf, sizeof(buf), "%03d", nr);
 		assert(nr == 3);
@@ -318,7 +318,7 @@ static void append_body_bytes_sent(struct clogger *c)
 	const char *fmt = sizeof(off_t) == sizeof(long) ? "%ld" : "%lld";
 	int nr = snprintf(buf, sizeof(buf), fmt, c->body_bytes_sent);
 
-	assert(nr > 0 && nr < sizeof(buf));
+	assert(nr > 0 && nr < (int)sizeof(buf));
 	rb_str_buf_cat(c->log_buf, buf, nr);
 }
 
@@ -327,11 +327,11 @@ static void append_tv(struct clogger *c, const VALUE *op, struct timeval *tv)
 	char buf[sizeof(".000000") + ((sizeof(tv->tv_sec) * 8) / 3)];
 	int nr;
 	char *fmt = RSTRING_PTR(op[1]);
-	int div = NUM2INT(op[2]);
+	int ndiv = NUM2INT(op[2]);
 
 	nr = snprintf(buf, sizeof(buf), fmt,
-		      (int)tv->tv_sec, (int)(tv->tv_usec / div));
-	assert(nr > 0 && nr < sizeof(buf));
+		      (int)tv->tv_sec, (int)(tv->tv_usec / ndiv));
+	assert(nr > 0 && nr < (int)sizeof(buf));
 	rb_str_buf_cat(c->log_buf, buf, nr);
 }
 
@@ -430,7 +430,7 @@ static void append_pid(struct clogger *c)
 	char buf[(sizeof(pid_t) * 8) / 3 + 1];
 	int nr = snprintf(buf, sizeof(buf), "%d", (int)getpid());
 
-	assert(nr > 0 && nr < sizeof(buf));
+	assert(nr > 0 && nr < (int)sizeof(buf));
 	rb_str_buf_cat(c->log_buf, buf, nr);
 }
 
@@ -472,7 +472,7 @@ static void append_response(struct clogger *c, VALUE key)
 {
 	VALUE v;
 
-	assert(rb_obj_class(c->headers) == cHeaderHash);
+	assert(rb_obj_is_kind_of(c->headers, cHeaderHash) && "not HeaderHash");
 
 	v = rb_funcall(c->headers, sq_brace_id, 1, key);
 	v = NIL_P(v) ? g_dash : byte_xs(v);
@@ -522,7 +522,7 @@ static VALUE cwrite(struct clogger *c)
 
 	for (; --i >= 0; ary++) {
 		const VALUE *op = RARRAY_PTR(*ary);
-		enum clogger_opcode opcode = NUM2INT(op[0]);
+		enum clogger_opcode opcode = FIX2INT(op[0]);
 
 		switch (opcode) {
 		case CL_OP_LITERAL:
@@ -535,7 +535,7 @@ static VALUE cwrite(struct clogger *c)
 			append_response(c, op[1]);
 			break;
 		case CL_OP_SPECIAL:
-			special_var(c, NUM2INT(op[1]));
+			special_var(c, FIX2INT(op[1]));
 			break;
 		case CL_OP_EVAL:
 			append_eval(c, op[1]);
@@ -592,8 +592,9 @@ static VALUE clogger_init(int argc, VALUE *argv, VALUE self)
 
 		c->logger = rb_hash_aref(o, ID2SYM(rb_intern("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));
+			rb_rescue(obj_enable_sync, c->logger, NULL, 0);
+			tmp = rb_rescue(obj_fileno, c->logger, NULL, 0);
+			c->fd = raw_fd(tmp);
 		}
 
 		tmp = rb_hash_aref(o, ID2SYM(rb_intern("format")));
@@ -703,17 +704,20 @@ static VALUE ccall(struct clogger *c, VALUE env)
 		c->body = tmp[2];
 
 		rv = rb_ary_new4(3, tmp);
-		if (c->need_resp && cHeaderHash != rb_obj_class(c->headers)) {
+		if (c->need_resp &&
+                    ! rb_obj_is_kind_of(tmp[1], cHeaderHash)) {
 			c->headers = rb_funcall(cHeaderHash, new_id, 1, tmp[1]);
 			rb_ary_store(rv, 1, c->headers);
 		}
 	} else {
-		c->status = INT2NUM(500);
+		volatile VALUE tmp = rb_inspect(rv);
+
+		c->status = INT2FIX(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)));
+			 RSTRING_PTR(tmp));
 	}
 
 	return rv;
@@ -775,21 +779,10 @@ static VALUE clogger_init_copy(VALUE clone, VALUE orig)
 
 #define CONST_GLOBAL_STR(val) CONST_GLOBAL_STR2(val, #val)
 
-static void init_rack_utils_header_hash(void)
-{
-	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)
 {
+	VALUE tmp;
+
 	ltlt_id = rb_intern("<<");
 	call_id = rb_intern("call");
 	each_id = rb_intern("each");
@@ -821,9 +814,11 @@ void Init_clogger_ext(void)
 	CONST_GLOBAL_STR2(rack_input, "rack.input");
 	CONST_GLOBAL_STR2(rack_multithread, "rack.multithread");
 	CONST_GLOBAL_STR2(dash, "-");
-	CONST_GLOBAL_STR2(empty, "");
 	CONST_GLOBAL_STR2(space, " ");
 	CONST_GLOBAL_STR2(question_mark, "?");
 	CONST_GLOBAL_STR2(rack_request_cookie_hash, "rack.request.cookie_hash");
-	init_rack_utils_header_hash();
+
+	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"));
 }

data/lib/clogger.rb

@@ -1,6 +1,8 @@
 # -*- encoding: binary -*-
+autoload :Rack, 'rack'
+
 class Clogger
-  VERSION = '0.3.2'
+  VERSION = '0.4.0'
 
   OP_LITERAL = 0
   OP_REQUEST = 1

data/lib/clogger/pure.rb

@@ -1,13 +1,14 @@
 # -*- 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
 
   def initialize(app, opts = {})
+    # trigger autoload to avoid thread-safety issues later on
+    Rack::Utils::HeaderHash.new({})
+
     @app = app
     @logger = opts[:logger]
     (@logger.sync = true) rescue nil

data/test/test_clogger.rb

@@ -587,6 +587,24 @@ class TestClogger < Test::Unit::TestCase
     assert ! cl.reentrant?
   end
 
+  def test_invalid_status
+    s = []
+    body = []
+    app = lambda { |env| [ env["force.status"], [ %w(a b) ], body ] }
+    o = { :logger => s, :format => "$status" }
+    cl = Clogger.new(app, o)
+    status, headers, body = cl.call(@req.merge("force.status" => -1))
+    assert_equal -1, status
+    assert_equal "-\n", s.last
+    status, headers, body = cl.call(@req.merge("force.status" => 1000))
+    assert_equal 1000, status
+    assert_equal "-\n", s.last
+    u64_max = 0xffffffffffffffff
+    status, headers, body = cl.call(@req.merge("force.status" => u64_max))
+    assert_equal u64_max, status
+    assert_equal "-\n", s.last
+  end
+
   # so we don't  care about the portability of this test
   # if it doesn't leak on Linux, it won't leak anywhere else
   # unless your C compiler or platform is otherwise broken
@@ -603,6 +621,6 @@ class TestClogger < Test::Unit::TestCase
       diff = after - before
       assert(diff < 10000, "memory grew more than 10M: #{diff}")
     end
-  end if RUBY_PLATFORM =~ /linux/ && test(?r, LINUX_PROC_PID_STATUS)
+  end if RUBY_PLATFORM =~ /linux/ && File.readable?(LINUX_PROC_PID_STATUS)
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: clogger
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors: 
 - cloggers
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-13 00:00:00 +00:00
+date: 2010-04-21 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency