agoo 1.2.2 → 2.0.0

data/ext/agoo/con.h

@@ -11,31 +11,33 @@
 #include "request.h"
 #include "response.h"
 #include "server.h"
+#include "types.h"
 
 #define MAX_HEADER_SIZE	8192
 
+struct _CSlot;
+
 typedef struct _Con {
     int			sock;
+    ConKind		kind;
     struct pollfd	*pp;
-    //char		id[32];
-    uint64_t		iid;
+    uint64_t		id;
     char		buf[MAX_HEADER_SIZE];
     size_t		bcnt;
 
     ssize_t		mcnt;  // how much has been read so far
     ssize_t		wcnt;  // how much has been written
 
-    Server		server;
     double		timeout;
     bool		closing;
     Req			req;
     Res			res_head;
     Res			res_tail;
 
-    //FEval		eval;
+    struct _CSlot	*slot; // only set for push connections
 } *Con;
 
-extern Con		con_create(Err err, Server server, int sock, uint64_t id);
+extern Con		con_create(Err err, int sock, uint64_t id);
 extern void		con_destroy(Con c);
 extern const char*	con_header_value(const char *header, int hlen, const char *key, int *vlen);
 

data/ext/agoo/debug.c

@@ -1,12 +1,28 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
+#include <pthread.h>
+#include <stdbool.h>
 #include <stdio.h>
 
 #include <ruby.h>
+#include <ruby/thread.h>
 
 #include "debug.h"
 
+typedef struct _Rec {
+    struct _Rec	*next;
+    void	*ptr;
+    const char	*type;
+    const char	*file;
+    int		line;
+} *Rec;
+
+static pthread_mutex_t	lock = PTHREAD_MUTEX_INITIALIZER;
+static Rec		recs = NULL;
+
+atomic_int	mem_cb = 0;
 atomic_int	mem_con = 0;
+atomic_int	mem_cslot = 0;
 atomic_int	mem_err_stream = 0;
 atomic_int	mem_eval_threads = 0;
 atomic_int	mem_header = 0;
@@ -20,6 +36,7 @@ atomic_int	mem_page = 0;
 atomic_int	mem_page_msg = 0;
 atomic_int	mem_page_path = 0;
 atomic_int	mem_page_slot = 0;
+atomic_int	mem_pub = 0;
 atomic_int	mem_qitem = 0;
 atomic_int	mem_queue_item = 0;
 atomic_int	mem_rack_logger = 0;
@@ -27,19 +44,49 @@ atomic_int	mem_req = 0;
 atomic_int	mem_res = 0;
 atomic_int	mem_res_body = 0;
 atomic_int	mem_response = 0;
-atomic_int	mem_server = 0;
 atomic_int	mem_text = 0;
 atomic_int	mem_to_s = 0;
 
-void
-debug_print_stats() {
 #ifdef MEM_DEBUG
-    rb_gc_enable();
-    rb_gc();
-    
+static void
+print_stats() {
+    Rec	r;
+
+    printf("********************************************************************************\n");
+    pthread_mutex_lock(&lock);
+
+    while (NULL != (r = recs)) {
+	int	cnt = 1;
+	Rec	prev = NULL;
+	Rec	next = NULL;
+	Rec	r2;
+	
+	recs = r->next;
+	for (r2 = recs; NULL != r2; r2 = next) {
+	    next = r2->next;
+	    if (r->file == r2->file && r->line == r2->line) {
+		cnt++;
+		if (NULL == prev) {
+		    recs = r2->next;
+		} else {
+		    prev->next = r2->next;
+		}
+		free(r2);
+	    } else {
+		prev = r2;
+	    }
+	}
+	printf("%16s:%3d %-12s allocated and not freed %4d times.\n", r->file, r->line, r->type + 4, cnt);
+	free(r);
+    }
+    pthread_mutex_unlock(&lock);	
+
     printf("********************************************************************************\n");
+#if 0
     printf("memory statistics\n");
+    printf("  mem_cb:           %d\n", mem_cb);
     printf("  mem_con:          %d\n", mem_con);
+    printf("  mem_cslot:        %d\n", mem_cslot);
     printf("  mem_err_stream:   %d\n", mem_err_stream);
     printf("  mem_eval_threads: %d\n", mem_eval_threads);
     printf("  mem_header:       %d\n", mem_header);
@@ -53,6 +100,7 @@ debug_print_stats() {
     printf("  mem_page_msg:     %d\n", mem_page_msg);
     printf("  mem_page_path:    %d\n", mem_page_path);
     printf("  mem_page_slot:    %d\n", mem_page_slot);
+    printf("  mem_pub:          %d\n", mem_pub);
     printf("  mem_qitem:        %d\n", mem_qitem);
     printf("  mem_queue_item:   %d\n", mem_queue_item);
     printf("  mem_rack_logger:  %d\n", mem_rack_logger);
@@ -60,8 +108,74 @@ debug_print_stats() {
     printf("  mem_res:          %d\n", mem_res);
     printf("  mem_res_body:     %d\n", mem_res_body);
     printf("  mem_response:     %d\n", mem_response);
-    printf("  mem_server:       %d\n", mem_server);
     printf("  mem_text:         %d\n", mem_text);
     printf("  mem_to_s:         %d\n", mem_to_s);
 #endif
 }
+#endif
+
+#if 0
+static void*
+handle_gc(void *x) {
+    rb_gc_enable();
+    rb_gc();
+    return NULL;
+}
+#endif
+
+void
+debug_report() {
+#ifdef MEM_DEBUG
+    // TBD how can ownership of GVL be determined?
+    //rb_thread_call_with_gvl(handle_gc, NULL);
+    print_stats();
+#endif
+}
+
+void
+debug_rreport() {
+#ifdef MEM_DEBUG
+    rb_gc_enable();
+    rb_gc();
+    print_stats();
+#endif
+}
+
+void
+debug_add(void *ptr, const char *type, const char *file, int line) {
+    Rec	r = (Rec)malloc(sizeof(struct _Rec));
+    
+    r->ptr = ptr;
+    r->type = type;
+    r->file = file;
+    r->line = line;
+    pthread_mutex_lock(&lock);	
+    r->next = recs;
+    recs = r;
+    pthread_mutex_unlock(&lock);	
+}
+
+void
+debug_del(void *ptr, const char *file, int line) {
+    Rec	r = NULL;
+    Rec	prev = NULL;
+    
+    pthread_mutex_lock(&lock);
+    for (r = recs; NULL != r; r = r->next) {
+	if (ptr == r->ptr) {
+	    if (NULL == prev) {
+		recs = r->next;
+	    } else {
+		prev->next = r->next;
+	    }
+	    break;
+	}
+	prev = r;
+    }
+    pthread_mutex_unlock(&lock);
+    if (NULL == r) {
+	printf("Free at %s:%d (%p) not allocated or already freed.\n", file, line, ptr);
+    } else {
+	free(r);
+    }
+}

data/ext/agoo/debug.h

@@ -6,14 +6,16 @@
 #include <stdatomic.h>
 
 #ifdef MEM_DEBUG
-#define DEBUG_ALLOC(var) { atomic_fetch_add(&var, 1); }
-#define DEBUG_FREE(var) { atomic_fetch_sub(&var, 1); }
+#define DEBUG_ALLOC(var, ptr) { atomic_fetch_add(&var, 1); debug_add(ptr, #var, __FILE__, __LINE__); }
+#define DEBUG_FREE(var, ptr) { atomic_fetch_sub(&var, 1); debug_del(ptr, __FILE__, __LINE__); }
 #else
-#define DEBUG_ALLOC(var) { }
-#define DEBUG_FREE(var) { }
+#define DEBUG_ALLOC(var, ptr) { }
+#define DEBUG_FREE(var, ptr) { }
 #endif
 
+extern atomic_int	mem_cb;
 extern atomic_int	mem_con;
+extern atomic_int	mem_cslot;
 extern atomic_int	mem_err_stream;
 extern atomic_int	mem_eval_threads;
 extern atomic_int	mem_header;
@@ -27,6 +29,7 @@ extern atomic_int	mem_page;
 extern atomic_int	mem_page_msg;
 extern atomic_int	mem_page_path;
 extern atomic_int	mem_page_slot;
+extern atomic_int	mem_pub;
 extern atomic_int	mem_qitem;
 extern atomic_int	mem_queue_item;
 extern atomic_int	mem_rack_logger;
@@ -34,10 +37,12 @@ extern atomic_int	mem_req;
 extern atomic_int	mem_res;
 extern atomic_int	mem_res_body;
 extern atomic_int	mem_response;
-extern atomic_int	mem_server;
 extern atomic_int	mem_text;
 extern atomic_int	mem_to_s;
 
-extern void	debug_print_stats();
+extern void	debug_add(void *ptr, const char *type, const char *file, int line);
+extern void	debug_del(void *ptr, const char *file, int line);
+extern void	debug_report();
+extern void	debug_rreport(); // when called from ruby
 
 #endif /* __AGOO_DEBUG_H__ */

data/ext/agoo/error_stream.c

@@ -15,19 +15,18 @@ static void
 es_free(void *ptr) {
     ErrorStream	es = (ErrorStream)ptr;
 
-    DEBUG_FREE(mem_err_stream)
-    DEBUG_FREE(mem_text)
+    DEBUG_FREE(mem_err_stream, ptr);
+    DEBUG_FREE(mem_text, es->text)
     free(es->text); // allocated with malloc
     xfree(ptr);
 }
 
 VALUE
-error_stream_new(Server server) {
+error_stream_new() {
     ErrorStream	es = ALLOC(struct _ErrorStream);
 
-    DEBUG_ALLOC(mem_err_stream)
+    DEBUG_ALLOC(mem_err_stream, es)
     es->text = text_allocate(1024);
-    es->server = server;
     
     return Data_Wrap_Struct(es_class, NULL, es_free, es);
 }
@@ -75,7 +74,7 @@ static VALUE
 es_flush(VALUE self) {
     ErrorStream	es = (ErrorStream)DATA_PTR(self);
 
-    log_cat(&es->server->error_cat, "%s", es->text->text);
+    log_cat(&error_cat, "%s", es->text->text);
     es->text->len = 0;
 
     return self;

data/ext/agoo/error_stream.h

@@ -8,6 +8,6 @@
 #include "server.h"
 
 extern void	error_stream_init(VALUE mod);
-extern VALUE	error_stream_new(Server server);
+extern VALUE	error_stream_new();
 
 #endif // __AGOO_ERROR_STREAM_H__

data/ext/agoo/extconf.rb

@@ -5,7 +5,8 @@ extension_name = 'agoo'
 dir_config(extension_name)
 
 $CPPFLAGS += " -DPLATFORM_LINUX" if 'x86_64-linux' == RUBY_PLATFORM
-RbConfig::MAKEFILE_CONFIG['CC'] = "gcc-6" if 'x86_64-linux' == RUBY_PLATFORM
+# Travis defaults to an older version of gcc to force a newer version.
+RbConfig::MAKEFILE_CONFIG['CC'] = "gcc-7" if 'x86_64-linux' == RUBY_PLATFORM
 
 create_makefile(File.join(extension_name, extension_name))
 

data/ext/agoo/hook.c

@@ -11,7 +11,7 @@ hook_create(Method method, const char *pattern, VALUE handler) {
     Hook	hook = (Hook)malloc(sizeof(struct _Hook));
 
     if (NULL != hook) {
-	DEBUG_ALLOC(mem_hook)
+	DEBUG_ALLOC(mem_hook, hook)
 	if (NULL == pattern) {
 	    pattern = "";
 	}
@@ -19,7 +19,7 @@ hook_create(Method method, const char *pattern, VALUE handler) {
 	hook->handler = handler;
 	rb_gc_register_address(&handler);
 	hook->pattern = strdup(pattern);
-	DEBUG_ALLOC(mem_hook_pattern)
+	DEBUG_ALLOC(mem_hook_pattern, hook->pattern)
 	hook->method = method;
 	if (rb_respond_to(handler, rb_intern("on_request"))) {
 	    hook->type = BASE_HOOK;
@@ -39,8 +39,8 @@ hook_create(Method method, const char *pattern, VALUE handler) {
 
 void
 hook_destroy(Hook hook) {
-    DEBUG_FREE(mem_hook_pattern)
-    DEBUG_FREE(mem_hook)
+    DEBUG_FREE(mem_hook_pattern, hook->pattern)
+	DEBUG_FREE(mem_hook, hook)
     free(hook->pattern);
     free(hook);
 }

data/ext/agoo/hook.h

@@ -14,6 +14,7 @@ typedef enum {
     RACK_HOOK	= 'R',
     BASE_HOOK	= 'B',
     WAB_HOOK	= 'W',
+    PUSH_HOOK	= 'P',
 } HookType;
 
 typedef struct _Hook {

data/ext/agoo/http.c

@@ -471,7 +471,7 @@ key_set(const char *key) {
     Slot	s;
     
     if (NULL != (s = (Slot)malloc(sizeof(struct _Slot)))) {
-	DEBUG_ALLOC(mem_http_slot)
+	DEBUG_ALLOC(mem_http_slot, s)
 	s->hash = h;
 	s->klen = len;
 	s->key = key;
@@ -499,7 +499,7 @@ http_cleanup() {
     for (int i = BUCKET_SIZE; 0 < i; i--, sp++) {
 	for (s = *sp; NULL != s; s = n) {
 	    n = s->next;
-	    DEBUG_FREE(mem_http_slot)
+	    DEBUG_FREE(mem_http_slot, s)
 	    free(s);
 	}
 	*sp = NULL;

data/ext/agoo/http.h

@@ -6,6 +6,8 @@
 #include <stdbool.h>
 
 extern void		http_init();
+extern void		http_cleanup();
+
 extern void		http_header_ok(const char *key, int klen, const char *value, int vlen);
 
 extern const char*	http_code_message(int code);

data/ext/agoo/log.c

@@ -45,6 +45,20 @@ static struct _Color	colors[] = {
 
 static const char	level_chars[] = { 'F', 'E', 'W', 'I', 'D', '?' };
 
+static VALUE	log_mod = Qundef;
+
+struct _Log	the_log = {NULL};
+struct _LogCat	fatal_cat;
+struct _LogCat	error_cat;
+struct _LogCat	warn_cat;
+struct _LogCat	info_cat;
+struct _LogCat	debug_cat;
+struct _LogCat	con_cat;
+struct _LogCat	req_cat;
+struct _LogCat	resp_cat;
+struct _LogCat	eval_cat;
+struct _LogCat	push_cat;
+
 static Color
 find_color(const char *name) {
     if (NULL != name) {
@@ -58,42 +72,42 @@ find_color(const char *name) {
 }
 
 static bool
-log_queue_empty(Log log) {
-    LogEntry	head = atomic_load(&log->head);
+log_queue_empty() {
+    LogEntry	head = atomic_load(&the_log.head);
     LogEntry	next = head + 1;
 
-    if (log->end <= next) {
-	next = log->q;
+    if (the_log.end <= next) {
+	next = the_log.q;
     }
-    if (!head->ready && log->tail == next) {
+    if (!head->ready && the_log.tail == next) {
 	return true;
     }
     return false;
 }
 
 static LogEntry
-log_queue_pop(Log log, double timeout) {
-    LogEntry	e = log->head;
+log_queue_pop(double timeout) {
+    LogEntry	e = the_log.head;
     LogEntry	next;
 
     if (e->ready) {
 	return e;
     }
-    next = log->head + 1;
-    if (log->end <= next) {
-	next = log->q;
+    next = the_log.head + 1;
+    if (the_log.end <= next) {
+	next = the_log.q;
     }
     // If the next is the tail then wait for something to be appended.
-    for (int cnt = (int)(timeout / RETRY_SECS); atomic_load(&log->tail) == next; cnt--) {
+    for (int cnt = (int)(timeout / RETRY_SECS); atomic_load(&the_log.tail) == next; cnt--) {
 	// TBD poll would be better
 	if (cnt <= 0) {
 	    return NULL;
 	}
 	dsleep(RETRY_SECS);
     }
-    atomic_store(&log->head, next);
+    atomic_store(&the_log.head, next);
 
-    return log->head;
+    return the_log.head;
 }
 
 
@@ -110,7 +124,7 @@ jwrite(LogEntry e, FILE *file) {
 
 //I 2015/05/23 11:22:33.123456789 label: The contents of the what field.
 static int
-classic_write(Log log, LogEntry e, FILE *file) {
+classic_write(LogEntry e, FILE *file) {
     time_t	t = (time_t)(e->when / 1000000000LL);
     int		hour = 0;
     int		min = 0;
@@ -119,9 +133,9 @@ classic_write(Log log, LogEntry e, FILE *file) {
     char	levelc = level_chars[e->cat->level];
     int		cnt = 0;
     
-    t += log->zone;
-    if (log->day_start <= t && t < log->day_end) {
-	t -= log->day_start;
+    t += the_log.zone;
+    if (the_log.day_start <= t && t < the_log.day_end) {
+	t -= the_log.day_start;
 	hour = (int)(t / 3600);
 	min = t % 3600 / 60;
 	sec = t % 60;
@@ -131,19 +145,19 @@ classic_write(Log log, LogEntry e, FILE *file) {
 	hour = tm->tm_hour;
 	min = tm->tm_min;
 	sec = tm->tm_sec;
-	sprintf(log->day_buf, "%04d/%02d/%02d ", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
-	log->day_start = t - (hour * 3600 + min * 60 + sec);
-	log->day_end = log->day_start + 86400;
+	sprintf(the_log.day_buf, "%04d/%02d/%02d ", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday);
+	the_log.day_start = t - (hour * 3600 + min * 60 + sec);
+	the_log.day_end = the_log.day_start + 86400;
     }
-    if (log->colorize) {
+    if (the_log.colorize) {
 	cnt = fprintf(file, "%s%c %s%02d:%02d:%02d.%09lld %s: %s%s\n",
-		      e->cat->color->ansi, levelc, log->day_buf, hour, min, sec, frac,
+		      e->cat->color->ansi, levelc, the_log.day_buf, hour, min, sec, frac,
 		      e->cat->label,
 		      (NULL == e->whatp ? e->what : e->whatp),
 		      RESET_COLOR);
     } else {
 	cnt += fprintf(file, "%c %s%02d:%02d:%02d.%09lld %s: %s\n",
-		       levelc, log->day_buf, hour, min, sec, frac,
+		       levelc, the_log.day_buf, hour, min, sec, frac,
 		       e->cat->label,
 		       (NULL == e->whatp ? e->what : e->whatp));
     }
@@ -153,12 +167,12 @@ classic_write(Log log, LogEntry e, FILE *file) {
 // Remove all file with sequence numbers higher than max_files. max_files is
 // max number of archived version. It does not include the primary.
 static void
-remove_old_logs(Log log) {
+remove_old_logs() {
     struct dirent	*de;
     long		seq;
     char		*end;
     char		path[1024];
-    DIR			*dir = opendir(log->dir);
+    DIR			*dir = opendir(the_log.dir);
     
     while (NULL != (de = readdir(dir))) {
 	if ('.' == *de->d_name || '\0' == *de->d_name) {
@@ -172,67 +186,64 @@ remove_old_logs(Log log) {
 	    continue;
 	}
 	seq = strtol(de->d_name + sizeof(log_prefix) - 1, &end, 10);
-	if (log->max_files < seq) {
-	    snprintf(path, sizeof(path), "%s/%s", log->dir, de->d_name);
+	if (the_log.max_files < seq) {
+	    snprintf(path, sizeof(path), "%s/%s", the_log.dir, de->d_name);
 	    remove(path);
 	}
     }
     closedir(dir);
 }
 
-static int
-rotate(Err err, Log log) {
+void
+log_rotate() {
     char	from[1024];
     char	to[1024];
 
-    if (NULL != log->file) {
-	fclose(log->file);
-	log->file = NULL;
+    if (NULL != the_log.file) {
+	fclose(the_log.file);
+	the_log.file = NULL;
     }
-    for (int seq = log->max_files; 0 < seq; seq--) {
-	snprintf(to, sizeof(to), log_format, log->dir, seq + 1);
-	snprintf(from, sizeof(from), log_format, log->dir, seq);
+    for (int seq = the_log.max_files; 0 < seq; seq--) {
+	snprintf(to, sizeof(to), log_format, the_log.dir, seq + 1);
+	snprintf(from, sizeof(from), log_format, the_log.dir, seq);
 	rename(from, to);
     }
-    snprintf(to, sizeof(to), log_format, log->dir, 1);
-    snprintf(from, sizeof(from), "%s/%s", log->dir, log_name);
+    snprintf(to, sizeof(to), log_format, the_log.dir, 1);
+    snprintf(from, sizeof(from), "%s/%s", the_log.dir, log_name);
     rename(from, to);
 
-    log->file = fopen(from, "w");
-    log->size = 0;
+    the_log.file = fopen(from, "w");
+    the_log.size = 0;
 
-    remove_old_logs(log);
-
-    return ERR_OK;
+    remove_old_logs();
 }
 
 static void*
 loop(void *ctx) {
-    Log		log = (Log)ctx;
     LogEntry	e;
 
-    while (!log->done || !log_queue_empty(log)) {
-	if (NULL != (e = log_queue_pop(log, 0.5))) {
-	    if (log->console) {
-		if (log->classic) {
-		    classic_write(log, e, stdout);
+    while (!the_log.done || !log_queue_empty()) {
+	if (NULL != (e = log_queue_pop(0.5))) {
+	    if (the_log.console) {
+		if (the_log.classic) {
+		    classic_write(e, stdout);
 		} else {
 		    jwrite(e, stdout);
 		}
 	    }
-	    if (NULL != log->file) {
-		if (log->classic) {
-		    log->size += classic_write(log, e, log->file);
+	    if (NULL != the_log.file) {
+		if (the_log.classic) {
+		    the_log.size += classic_write(e, the_log.file);
 		} else {
-		    log->size += jwrite(e, log->file);
+		    the_log.size += jwrite(e, the_log.file);
 		}
-		if (log->max_size <= log->size) {
-		    rotate(NULL, log);
+		if (the_log.max_size <= the_log.size) {
+		    log_rotate();
 		}
 	    }
 	    if (NULL != e->whatp) {
 		free(e->whatp);
-		DEBUG_FREE(mem_log_what)
+		DEBUG_FREE(mem_log_what, e->whatp)
 	    }
 	    e->ready = false;
 	}
@@ -241,191 +252,78 @@ loop(void *ctx) {
 }
 
 bool
-log_flush(Log log, double timeout) {
+log_flush(double timeout) {
     timeout += dtime();
     
-    while (!log->done && !log_queue_empty(log)) {
+    while (!the_log.done && !log_queue_empty()) {
 	if (timeout < dtime()) {
 	    return false;
 	}
 	dsleep(0.001);
     }
-    if (NULL != log->file) {
-	fflush(log->file);
+    if (NULL != the_log.file) {
+	fflush(the_log.file);
     }
     return true;
 }
 
-static int
-configure(Err err, Log log, VALUE options) {
-    if (Qnil != options) {
-	VALUE	v;
-
-	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("log_dir"))))) {
-	    rb_check_type(v, T_STRING);
-	    strncpy(log->dir, StringValuePtr(v), sizeof(log->dir));
-	    log->dir[sizeof(log->dir) - 1] = '\0';
-	}
-	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("log_max_files"))))) {
-	    int	max = FIX2INT(v);
-
-	    if (1 <= max || max < 100) {
-		log->max_files = max;
-	    } else {
-		rb_raise(rb_eArgError, "log_max_files must be between 1 and 100.");
-	    }
-	}
-	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("log_max_size"))))) {
-	    int	max = FIX2INT(v);
-
-	    if (1 <= max) {
-		log->max_size = max;
-	    } else {
-		rb_raise(rb_eArgError, "log_max_size must be 1 or more.");
-	    }
-	}
-	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("log_console"))))) {
-	    log->console = (Qtrue == v);
-	}
-	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("log_classic"))))) {
-	    log->classic = (Qtrue == v);
-	}
-	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("log_colorize"))))) {
-	    log->colorize = (Qtrue == v);
-	}
-	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("log_states"))))) {
-	    if (T_HASH == rb_type(v)) {
-		LogCat	cat = log->cats;
-		VALUE	cv;
-		
-		for (; NULL != cat; cat = cat->next) {
-		    if (Qnil != (cv = rb_hash_lookup(v, ID2SYM(rb_intern(cat->label))))) {
-			if (Qtrue == cv) {
-			    cat->on = true;
-			} else if (Qfalse == cv) {
-			    cat->on = false;
-			}
-		    }
-		}
-	    } else {
-		rb_raise(rb_eArgError, "log_states must be a Hash.");
-	    }
-	}
-    }
-    return ERR_OK;
-}
-
-static int
-open_log_file(Err err, Log log) {
+static void
+open_log_file() {
     char	path[1024];
 
-    snprintf(path, sizeof(path), "%s/%s", log->dir, log_name);
+    snprintf(path, sizeof(path), "%s/%s", the_log.dir, log_name);
 
-    log->file = fopen(path, "a");
-    if (NULL == log->file) {
-	return err_no(err, "failed to open '%s'.", path);
+    the_log.file = fopen(path, "a");
+    if (NULL == the_log.file) {
+	rb_raise(rb_eIOError, "Failed to create '%s'.", path);
     }
-    log->size = ftell(log->file);
-    if (log->max_size <= log->size) {
-	return rotate(err, log);
+    the_log.size = ftell(the_log.file);
+    if (the_log.max_size <= the_log.size) {
+	log_rotate();
     }
-    return ERR_OK;
-}
-
-int
-log_init(Err err, Log log, VALUE cfg) {
-    time_t	t = time(NULL);
-    struct tm	*tm = localtime(&t);
-    int		qsize = 1024;
-    
-    //log->cats = NULL; done outside of here
-    *log->dir = '\0';
-    log->file = NULL;
-    log->max_files = 3;
-    log->max_size = 100000000; // 100M
-    log->size = 0;
-    log->done = false;
-    log->console = true;
-    log->classic = true;
-    log->colorize = true;
-    log->zone = (int)(timegm(tm) - t);
-    log->day_start = 0;
-    log->day_end = 0;
-    *log->day_buf = '\0';
-    log->thread = 0;
-
-    if (ERR_OK != configure(err, log, cfg)) {
-	return err->code;
-    }
-    if ('\0' != *log->dir) {
-	if (0 != mkdir(log->dir, 0770) && EEXIST != errno) {
-	    return err_no(err, "Failed to create '%s'.", log->dir);
-	}
-	if (ERR_OK != open_log_file(err, log)) {
-	    return err->code;
-	}
-    }
-    log->q = (LogEntry)malloc(sizeof(struct _LogEntry) * qsize);
-    DEBUG_ALLOC(mem_log_entry)
-
-    log->end = log->q + qsize;
-
-    memset(log->q, 0, sizeof(struct _LogEntry) * qsize);
-    log->head = log->q;
-    log->tail = log->q + 1;
-    atomic_flag_clear(&log->push_lock);
-    log->wait_state = NOT_WAITING;
-    // Create when/if needed.
-    log->rsock = 0;
-    log->wsock = 0;
-    
-    pthread_create(&log->thread, NULL, loop, log);
-
-    return ERR_OK;
 }
 
 void
-log_close(Log log) {
-    log->done = true;
+log_close() {
+    the_log.done = true;
     // TBD wake up loop like push does
-    log_cat_on(log, NULL, false);
-    if (0 != log->thread) {
-	pthread_join(log->thread, NULL);
-	log->thread = 0;
+    log_cat_on(NULL, false);
+    if (0 != the_log.thread) {
+	pthread_join(the_log.thread, NULL);
+	the_log.thread = 0;
     }
-    if (NULL != log->file) {
-	fclose(log->file);
-	log->file = NULL;
+    if (NULL != the_log.file) {
+	fclose(the_log.file);
+	the_log.file = NULL;
     }
-    DEBUG_FREE(mem_log_entry)
-    free(log->q);
-    log->q = NULL;
-    log->end = NULL;
-    if (0 < log->wsock) {
-	close(log->wsock);
+    DEBUG_FREE(mem_log_entry, the_log.q)
+    free(the_log.q);
+    the_log.q = NULL;
+    the_log.end = NULL;
+    if (0 < the_log.wsock) {
+	close(the_log.wsock);
     }
-    if (0 < log->rsock) {
-	close(log->rsock);
+    if (0 < the_log.rsock) {
+	close(the_log.rsock);
     }
 }
 
 void
-log_cat_reg(Log log, LogCat cat, const char *label, LogLevel level, const char *color, bool on) {
-    cat->log = log;
+log_cat_reg(LogCat cat, const char *label, LogLevel level, const char *color, bool on) {
     strncpy(cat->label, label, sizeof(cat->label));
     cat->label[sizeof(cat->label) - 1] = '\0';
     cat->level = level;
     cat->color = find_color(color);
     cat->on = on;
-    cat->next = log->cats;
-    log->cats = cat;
+    cat->next = the_log.cats;
+    the_log.cats = cat;
 }
 
 void
-log_cat_on(Log log, const char *label, bool on) {
+log_cat_on(const char *label, bool on) {
     LogCat	cat;
 
-    for (cat = log->cats; NULL != cat; cat = cat->next) {
+    for (cat = the_log.cats; NULL != cat; cat = cat->next) {
 	if (NULL == label || 0 == strcasecmp(label, cat->label)) {
 	    cat->on = on;
 	    break;
@@ -434,10 +332,10 @@ log_cat_on(Log log, const char *label, bool on) {
 }
 
 LogCat
-log_cat_find(Log log, const char *label) {
+log_cat_find(const char *label) {
     LogCat	cat;
 
-    for (cat = log->cats; NULL != cat; cat = cat->next) {
+    for (cat = the_log.cats; NULL != cat; cat = cat->next) {
 	if (0 == strcasecmp(label, cat->label)) {
 	    return cat;
 	}
@@ -447,8 +345,7 @@ log_cat_find(Log log, const char *label) {
 
 void
 log_catv(LogCat cat, const char *fmt, va_list ap) {
-    if (cat->on && !cat->log->done) {
-	Log		log = cat->log;
+    if (cat->on && !the_log.done) {
 	struct timespec	ts;
 	LogEntry	e;
 	LogEntry	tail;
@@ -457,39 +354,39 @@ log_catv(LogCat cat, const char *fmt, va_list ap) {
 
 	va_copy(ap2, ap);
 	
-	while (atomic_flag_test_and_set(&log->push_lock)) {
+	while (atomic_flag_test_and_set(&the_log.push_lock)) {
 	    dsleep(RETRY_SECS);
 	}
 	// Wait for head to move on.
-	while (atomic_load(&log->head) == log->tail) {
+	while (atomic_load(&the_log.head) == the_log.tail) {
 	    dsleep(RETRY_SECS);
 	}
 	// TBD fill in the entry at tail
 	clock_gettime(CLOCK_REALTIME, &ts);
-	e = log->tail;
+	e = the_log.tail;
 	e->cat = cat;
 	e->when = (int64_t)ts.tv_sec * 1000000000LL + (int64_t)ts.tv_nsec;
 	e->whatp = NULL;
 	if ((int)sizeof(e->what) <= (cnt = vsnprintf(e->what, sizeof(e->what), fmt, ap))) {
 	    e->whatp = (char*)malloc(cnt + 1);
 
-	    DEBUG_ALLOC(mem_log_what)
+	    DEBUG_ALLOC(mem_log_what, e->whatp)
     
 	    if (NULL != e->whatp) {
 		vsnprintf(e->whatp, cnt + 1, fmt, ap2);
 	    }
 	}
-	tail = log->tail + 1;
-	if (log->end <= tail) {
-	    tail = log->q;
+	tail = the_log.tail + 1;
+	if (the_log.end <= tail) {
+	    tail = the_log.q;
 	}
-	atomic_store(&log->tail, tail);
-	atomic_flag_clear(&log->push_lock);
+	atomic_store(&the_log.tail, tail);
+	atomic_flag_clear(&the_log.push_lock);
 	va_end(ap2);
 
-	if (0 != log->wsock && WAITING == atomic_load(&log->wait_state)) {
-	    if (write(log->wsock, ".", 1)) {}
-	    atomic_store(&log->wait_state, NOTIFIED);
+	if (0 != the_log.wsock && WAITING == atomic_load(&the_log.wait_state)) {
+	    if (write(the_log.wsock, ".", 1)) {}
+	    atomic_store(&the_log.wait_state, NOTIFIED);
 	}
     }
 }
@@ -502,3 +399,491 @@ log_cat(LogCat cat, const char *fmt, ...) {
     log_catv(cat, fmt, ap);
     va_end(ap);
 }
+
+/* Document-method: configure
+ *
+ * call-seq: configure(options)
+ *
+ * Configures the logger
+ *
+ * - *options* [_Hash_] server options
+ *
+ *   - *:dir* [_String_] directory to place log files in. If nil or empty then no log files are written.
+ *
+ *   - *:console* [_true_|_false_] if true log entry are display on the console.
+ *
+ *   - *:classic* [_true_|_false_] if true log entry follow a classic format. If false log entries are JSON.
+ *
+ *   - *:colorize* [_true_|_false_] if true log entries are colorized.
+ *
+ *   - *:states* [_Hash_] a map of logging categories and whether they should be on or off. Categories are:
+ *     - *:ERROR* errors
+ *     - *:WARN* warnings
+ *     - *:INFO* infomational
+ *     - *:DEBUG* debugging
+ *     - *:connect* openning and closing of connections
+ *     - *:request* requests
+ *     - *:response* responses
+ *     - *:eval* handler evaluationss
+ *     - *:push* writes to WebSocket or SSE connection
+ */
+static VALUE
+rlog_configure(VALUE self, VALUE options) {
+    if (Qnil != options) {
+	VALUE	v;
+
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("dir"))))) {
+	    rb_check_type(v, T_STRING);
+	    strncpy(the_log.dir, StringValuePtr(v), sizeof(the_log.dir));
+	    the_log.dir[sizeof(the_log.dir) - 1] = '\0';
+	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("max_files"))))) {
+	    int	max = FIX2INT(v);
+
+	    if (1 <= max || max < 100) {
+		the_log.max_files = max;
+	    } else {
+		rb_raise(rb_eArgError, "max_files must be between 1 and 100.");
+	    }
+	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("max_size"))))) {
+	    int	max = FIX2INT(v);
+
+	    if (1 <= max) {
+		the_log.max_size = max;
+	    } else {
+		rb_raise(rb_eArgError, "max_size must be 1 or more.");
+	    }
+	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("console"))))) {
+	    the_log.console = (Qtrue == v);
+	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("classic"))))) {
+	    the_log.classic = (Qtrue == v);
+	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("colorize"))))) {
+	    the_log.colorize = (Qtrue == v);
+	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("states"))))) {
+	    if (T_HASH == rb_type(v)) {
+		LogCat	cat = the_log.cats;
+		VALUE	cv;
+		
+		for (; NULL != cat; cat = cat->next) {
+		    if (Qnil != (cv = rb_hash_lookup(v, ID2SYM(rb_intern(cat->label))))) {
+			if (Qtrue == cv) {
+			    cat->on = true;
+			} else if (Qfalse == cv) {
+			    cat->on = false;
+			}
+		    }
+		}
+	    } else {
+		rb_raise(rb_eArgError, "states must be a Hash.");
+	    }
+	}
+    }
+    if (NULL != the_log.file) {
+	fclose(the_log.file);
+	the_log.file = NULL;
+    }
+    if ('\0' != *the_log.dir) {
+	if (0 != mkdir(the_log.dir, 0770) && EEXIST != errno) {
+	    rb_raise(rb_eIOError, "Failed to create '%s'.", the_log.dir);
+	}
+	open_log_file();
+    }
+    return Qnil;
+}
+
+/* Document-method: shutdown
+ *
+ * call-seq: shutdown()
+ *
+ * Shutdown the logger. Writes are flushed before shutting down.
+ */
+static VALUE
+rlog_shutdown(VALUE self) {
+    log_close();
+    return Qnil;
+}
+
+/* Document-method: error?
+ *
+ * call-seq: error?()
+ *
+ * Returns true is errors are being logged.
+ */
+static VALUE
+rlog_errorp(VALUE self) {
+    return error_cat.on ? Qtrue : Qfalse;
+}
+
+/* Document-method: warn?
+ *
+ * call-seq: warn?()
+ *
+ * Returns true is warnings are being logged.
+ */
+static VALUE
+rlog_warnp(VALUE self) {
+    return warn_cat.on ? Qtrue : Qfalse;
+}
+
+/* Document-method: info?
+ *
+ * call-seq: info?()
+ *
+ * Returns true is info entries are being logged.
+ */
+static VALUE
+rlog_infop(VALUE self) {
+    return info_cat.on ? Qtrue : Qfalse;
+}
+
+/* Document-method: debug?
+ *
+ * call-seq: debug?()
+ *
+ * Returns true is debug entries are being logged.
+ */
+static VALUE
+rlog_debugp(VALUE self) {
+    return debug_cat.on ? Qtrue : Qfalse;
+}
+
+/* Document-method: error
+ *
+ * call-seq: error(msg)
+ *
+ * Log an error message.
+ */
+static VALUE
+rlog_error(VALUE self, VALUE msg) {
+    log_cat(&error_cat, "%s", StringValuePtr(msg));
+    return Qnil;
+}
+
+/* Document-method: warn
+ *
+ * call-seq: warn(msg)
+ *
+ * Log a warn message.
+ */
+static VALUE
+rlog_warn(VALUE self, VALUE msg) {
+    log_cat(&warn_cat, "%s", StringValuePtr(msg));
+    return Qnil;
+}
+
+/* Document-method: info
+ *
+ * call-seq: info(msg)
+ *
+ * Log an info message.
+ */
+static VALUE
+rlog_info(VALUE self, VALUE msg) {
+    log_cat(&info_cat, "%s", StringValuePtr(msg));
+    return Qnil;
+}
+
+/* Document-method: debug
+ *
+ * call-seq: debug(msg)
+ *
+ * Log a debug message.
+ */
+static VALUE
+rlog_debug(VALUE self, VALUE msg) {
+    log_cat(&debug_cat, "%s", StringValuePtr(msg));
+    return Qnil;
+}
+
+/* Document-method: color
+ *
+ * call-seq: color(label)
+ *
+ * Returns the current color name as a Symbol for the specified label.
+ */
+static VALUE
+rlog_color_get(VALUE self, VALUE label) {
+    LogCat	cat = log_cat_find(StringValuePtr(label));
+
+    if (NULL == cat) {
+	return Qnil;
+    }
+    return ID2SYM(rb_intern(cat->color->name));
+}
+
+/* Document-method: set_color
+ *
+ * call-seq: set_color(label, color_symbol)
+ *
+ * Sets color of the category associated with a label. Valid colors are
+ * :black, :red, :green, :yellow, :blue, :magenta, :cyan, :white, :gray,
+ * :dark_red, :dark_green, :brown, :dark_blue, :purple, and :dark_cyan.
+ */
+static VALUE
+rlog_color_set(VALUE self, VALUE label, VALUE color) {
+    const char	*label_str = StringValuePtr(label);
+    const char	*color_name = StringValuePtr(color);
+    LogCat	cat = log_cat_find(label_str);
+    Color	c = find_color(color_name);
+
+    if (NULL == cat) {
+	rb_raise(rb_eArgError, "%s is not a valid category.", label_str);
+    }
+    if (NULL == c) {
+	rb_raise(rb_eArgError, "%s is not a valid color.", color_name);
+    }
+    cat->color = c;
+    
+    return Qnil;
+}
+
+/* Document-method: state
+ *
+ * call-seq: state(label)
+ *
+ * Returns the current state of the category identified by the specified
+ * label.
+ */
+static VALUE
+rlog_on_get(VALUE self, VALUE label) {
+    LogCat	cat = log_cat_find(StringValuePtr(label));
+
+    if (NULL == cat) {
+	return Qfalse;
+    }
+    return cat->on ? Qtrue : Qfalse;
+}
+
+/* Document-method: set_state
+ *
+ * call-seq: set_state(label, state)
+ *
+ * Sets state of the category associated with a label.
+ */
+static VALUE
+rlog_on_set(VALUE self, VALUE label, VALUE state) {
+    const char	*label_str = StringValuePtr(label);
+    LogCat	cat = log_cat_find(label_str);
+
+    if (NULL == cat) {
+	rb_raise(rb_eArgError, "%s is not a valid category.", label_str);
+    }
+    cat->on = (Qtrue == state);
+    
+    return cat->on ? Qtrue : Qfalse;
+}
+
+/* Document-method: log
+ *
+ * call-seq: log[label] = msg
+ *
+ * Log a message in the specified category.
+ */
+static VALUE
+rlog_log(VALUE self, VALUE label, VALUE msg) {
+    const char	*label_str = StringValuePtr(label);
+    LogCat	cat = log_cat_find(label_str);
+
+    if (NULL == cat) {
+	rb_raise(rb_eArgError, "%s is not a valid category.", label_str);
+    }
+    log_cat(cat, "%s", StringValuePtr(msg));
+    
+    return Qnil;
+}
+
+/* Document-method: flush
+ *
+ * call-seq: flush
+ *
+ * Flush the log queue and write all entries to disk or the console. The call
+ * waits for the flush to complete or the timeout to be exceeded.
+ */
+static VALUE
+rlog_flush(VALUE self, VALUE to) {
+    double	timeout = NUM2DBL(to);
+    
+    if (!log_flush(timeout)) {
+	rb_raise(rb_eStandardError, "timed out waiting for log flush.");
+    }
+    return Qnil;
+}
+
+/* Document-method: rotate
+ *
+ * call-seq: rotate()
+ *
+ * Rotate the log files.
+ */
+static VALUE
+rlog_rotate(VALUE self) {
+    log_rotate();
+    return Qnil;
+}
+
+/* Document-method: console=
+ *
+ * call-seq: console=(on)
+ *
+ * If on then log output also goes to the console.
+ */
+static VALUE
+rlog_console(VALUE self, VALUE on) {
+    the_log.console = (Qtrue == on);
+    return Qnil;
+}
+
+/* Document-method: classic
+ *
+ * call-seq: classic()
+ *
+ * Set the log format to classic format.
+ */
+static VALUE
+rlog_classic(VALUE self) {
+    the_log.classic = true;
+    return Qnil;
+}
+
+/* Document-method: json
+ *
+ * call-seq: json()
+ *
+ * Set the log format to JSON format.
+ */
+static VALUE
+rlog_json(VALUE self) {
+    the_log.classic = false;
+    return Qnil;
+}
+
+/* Document-method: max_size
+ *
+ * call-seq: max_size(size)
+ *
+ * Maximum log files size is reset.
+ */
+static VALUE
+rlog_max_size(VALUE self, VALUE rmax) {
+    int	max = FIX2INT(rmax);
+
+    if (1 <= max) {
+	the_log.max_size = max;
+    } else {
+	rb_raise(rb_eArgError, "max_size must be 1 or more.");
+    }
+    return Qnil;
+}
+
+/* Document-method: max_files
+ *
+ * call-seq: max_files(max)
+ *
+ * Maximum log files files is reset.
+ */
+static VALUE
+rlog_max_files(VALUE self, VALUE rmax) {
+    int	max = FIX2INT(rmax);
+
+    if (1 <= max || max < 100) {
+	the_log.max_files = max;
+    } else {
+	rb_raise(rb_eArgError, "max_files must be between 1 and 100.");
+    }
+    return Qnil;
+}
+
+
+/* Document-class: Agoo::Log
+ *
+ * An asynchronous and thread safe logger that includes file rollover and
+ * multiple logging categories. It is a feature based logger with a level
+ * overlay.
+ */
+void
+log_init(VALUE mod) {
+    time_t	t = time(NULL);
+    struct tm	*tm = localtime(&t);
+    int		qsize = 1024;
+    
+    log_mod = rb_define_module_under(mod, "Log");
+
+    rb_define_module_function(log_mod, "configure", rlog_configure, 1);
+    rb_define_module_function(log_mod, "shutdown", rlog_shutdown, 0);
+
+    rb_define_module_function(log_mod, "error?", rlog_errorp, 0);
+    rb_define_module_function(log_mod, "warn?", rlog_warnp, 0);
+    rb_define_module_function(log_mod, "info?", rlog_infop, 0);
+    rb_define_module_function(log_mod, "debug?", rlog_debugp, 0);
+
+    rb_define_module_function(log_mod, "error", rlog_error, 1);
+    rb_define_module_function(log_mod, "warn", rlog_warn, 1);
+    rb_define_module_function(log_mod, "info", rlog_info, 1);
+    rb_define_module_function(log_mod, "debug", rlog_debug, 1);
+
+    // TBD maybe in a future version
+    //rb_define_module_function(log_mod, "register", rlog_register, 2);
+
+    rb_define_module_function(log_mod, "color", rlog_color_get, 1);
+    rb_define_module_function(log_mod, "set_color", rlog_color_set, 2);
+
+    rb_define_module_function(log_mod, "state", rlog_on_get, 1);
+    rb_define_module_function(log_mod, "set_state", rlog_on_set, 2);
+
+    rb_define_module_function(log_mod, "log", rlog_log, 2);
+
+    rb_define_module_function(log_mod, "flush", rlog_flush, 1);
+    rb_define_module_function(log_mod, "rotate", rlog_rotate, 0);
+    rb_define_module_function(log_mod, "console=", rlog_console, 1);
+    rb_define_module_function(log_mod, "classic", rlog_classic, 0);
+    rb_define_module_function(log_mod, "json", rlog_json, 0);
+    rb_define_module_function(log_mod, "max_size=", rlog_max_size, 1);
+    rb_define_module_function(log_mod, "max_files=", rlog_max_files, 1);
+
+    the_log.cats = NULL;
+    *the_log.dir = '\0';
+    the_log.file = NULL;
+    the_log.max_files = 3;
+    the_log.max_size = 100000000; // 100M
+    the_log.size = 0;
+    the_log.done = false;
+    the_log.console = true;
+    the_log.classic = true;
+    the_log.colorize = true;
+    the_log.zone = (int)(timegm(tm) - t);
+    the_log.day_start = 0;
+    the_log.day_end = 0;
+    *the_log.day_buf = '\0';
+    the_log.thread = 0;
+
+    the_log.q = (LogEntry)malloc(sizeof(struct _LogEntry) * qsize);
+    DEBUG_ALLOC(mem_log_entry, the_log.q)
+    the_log.end = the_log.q + qsize;
+    memset(the_log.q, 0, sizeof(struct _LogEntry) * qsize);
+    the_log.head = the_log.q;
+    the_log.tail = the_log.q + 1;
+
+    atomic_flag_clear(&the_log.push_lock);
+    the_log.wait_state = NOT_WAITING;
+    // Create when/if needed.
+    the_log.rsock = 0;
+    the_log.wsock = 0;
+
+    log_cat_reg(&fatal_cat, "FATAL",    FATAL, RED, true);
+    log_cat_reg(&error_cat, "ERROR",    ERROR, RED, true);
+    log_cat_reg(&warn_cat,  "WARN",     WARN,  YELLOW, true);
+    log_cat_reg(&info_cat,  "INFO",     INFO,  GREEN, true);
+    log_cat_reg(&debug_cat, "DEBUG",    DEBUG, GRAY, false);
+    log_cat_reg(&con_cat,   "connect",  INFO,  GREEN, false);
+    log_cat_reg(&req_cat,   "request",  INFO,  CYAN, false);
+    log_cat_reg(&resp_cat,  "response", INFO,  DARK_CYAN, false);
+    log_cat_reg(&eval_cat,  "eval",     INFO,  BLUE, false);
+    log_cat_reg(&push_cat,  "push",     INFO,  DARK_CYAN, false);
+
+    pthread_create(&the_log.thread, NULL, loop, log);
+}