agoo 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1210b704838b2b955043a6898f84de5314c807c2557310f4e1eb2049c4b92dc6
-  data.tar.gz: cb5d9a00fd52a2bad258e3ec946597ae2ebb76a6c8ee1a1f13f33fadd06bd200
+  metadata.gz: 6103f21468598e8f15a8a47bca17c2b7c1c358af72f8db93090cbf03e193677c
+  data.tar.gz: ee415fcfbb7a45daf9dbe52b286a03317bf900c667953b5cb632f9d1f34b19d9
 SHA512:
-  metadata.gz: 6139683e96c96440854aad33d252036942e020a0a38cd619802033c5ee3523306ee2ce356af4c0abf294b510bf2320dfb3544aa87b5d449d5a0b14ece8ea9b37
-  data.tar.gz: e1d8735be9d8036b6274dcd18baeb5e678ae47a9118d35ee4aca1b3b5ee9145d7836f51e72d82643a8a409a0164acfa5be2d4da8fa04563eb9378626c8be5356
+  metadata.gz: 8874e326ca975f994409a298526d12062a788d98c428f6cd71bd3c166ca53e15add697a5aebc0321ab37816dc37598da8ab667164d77d37de5317711f84de5f3
+  data.tar.gz: 23c8284929d79573cf5de03cf57cab3bf308db6ab53e0edb112d1b31bcf5c7cc5895aad4d231a55bfc75a7b77ea5e111b134d4514938ed6e0a19afc43e585927

data/ext/agoo/con.c

@@ -4,6 +4,7 @@
 #include <string.h>
 
 #include "con.h"
+#include "debug.h"
 #include "dtime.h"
 #include "hook.h"
 #include "http.h"
@@ -24,10 +25,10 @@ con_create(Err err, Server server, int sock, uint64_t id) {
     if (NULL == (c = (Con)malloc(sizeof(struct _Con)))) {
 	err_set(err, ERR_MEMORY, "Failed to allocate memory for a connection.");
     } else {
+	DEBUG_ALLOC(mem_con)
 	memset(c, 0, sizeof(struct _Con));
 	c->sock = sock;
 	c->iid = id;
-	sprintf(c->id, "%llu", (unsigned long long)id);
 	c->server = server;
     }
     return c;
@@ -41,7 +42,9 @@ con_destroy(Con c) {
     }
     if (NULL != c->req) {
 	free(c->req);
+	DEBUG_FREE(mem_req)
     }
+    DEBUG_FREE(mem_con)
     free(c);
 }
 
@@ -63,7 +66,7 @@ con_header_value(const char *header, int hlen, const char *key, int *vlen) {
 	    for (; '\r' != *h && '\0' != *h; h++) {
 	    }
 	    *vlen = (int)(h - value);
-
+ 
 	    return value;
 	}
 	for (; h < hend; h++) {
@@ -88,6 +91,7 @@ bad_request(Con c, int status, int line) {
 	int	cnt = snprintf(buf, sizeof(buf), "HTTP/1.1 %d %s\r\nConnection: Close\r\nContent-Length: 0\r\n\r\n", status, msg);
 	Text	message = text_create(buf, cnt);
 	
+	DEBUG_ALLOC(mem_res)
 	if (NULL == c->res_tail) {
 	    c->res_head = res;
 	} else {
@@ -266,6 +270,7 @@ HOOKED:
     if (NULL == (c->req = (Req)malloc(mlen + sizeof(struct _Req) - 8 + 1))) {
 	return bad_request(c, 413, __LINE__);
     }
+    DEBUG_ALLOC(mem_req)
     if ((long)c->bcnt <= mlen) {
 	memcpy(c->req->msg, c->buf, c->bcnt);
 	if ((long)c->bcnt < mlen) {
@@ -313,7 +318,7 @@ con_read(Con c) {
 	// If nothing read then no need to complain. Just close.
 	if (0 < c->bcnt) {
 	    if (0 == cnt) {
-		log_cat(&c->server->warn_cat, "Nothing to read. Client closed socket %s.", c->id);
+		log_cat(&c->server->warn_cat, "Nothing to read. Client closed socket on connection %llu.", c->iid);
 	    } else {
 		log_cat(&c->server->warn_cat, "Failed to read request. %s.", strerror(errno));
 	    }

data/ext/agoo/con.h

@@ -17,7 +17,7 @@
 typedef struct _Con {
     int			sock;
     struct pollfd	*pp;
-    char		id[32];
+    //char		id[32];
     uint64_t		iid;
     char		buf[MAX_HEADER_SIZE];
     size_t		bcnt;

data/ext/agoo/debug.c

@@ -0,0 +1,67 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdio.h>
+
+#include <ruby.h>
+
+#include "debug.h"
+
+atomic_int	mem_con = 0;
+atomic_int	mem_err_stream = 0;
+atomic_int	mem_eval_threads = 0;
+atomic_int	mem_header = 0;
+atomic_int	mem_hook = 0;
+atomic_int	mem_hook_pattern = 0;
+atomic_int	mem_http_slot = 0;
+atomic_int	mem_log_entry = 0;
+atomic_int	mem_log_what = 0;
+atomic_int	mem_mime_slot = 0;
+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_qitem = 0;
+atomic_int	mem_queue_item = 0;
+atomic_int	mem_rack_logger = 0;
+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();
+    
+    printf("********************************************************************************\n");
+    printf("memory statistics\n");
+    printf("  mem_con:          %d\n", mem_con);
+    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);
+    printf("  mem_hook:         %d\n", mem_hook);
+    printf("  mem_hook_pattern: %d\n", mem_hook_pattern);
+    printf("  mem_http_slot:    %d\n", mem_http_slot);
+    printf("  mem_log_entry:    %d\n", mem_log_entry);
+    printf("  mem_log_what:     %d\n", mem_log_what);
+    printf("  mem_mime_slot:    %d\n", mem_mime_slot);
+    printf("  mem_page:         %d\n", mem_page);
+    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_qitem:        %d\n", mem_qitem);
+    printf("  mem_queue_item:   %d\n", mem_queue_item);
+    printf("  mem_rack_logger:  %d\n", mem_rack_logger);
+    printf("  mem_req:          %d\n", mem_req);
+    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
+}

data/ext/agoo/debug.h

@@ -0,0 +1,43 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef __AGOO_DEBUG_H__
+#define __AGOO_DEBUG_H__
+
+#include <stdatomic.h>
+
+#ifdef MEM_DEBUG
+#define DEBUG_ALLOC(var) { atomic_fetch_add(&var, 1); }
+#define DEBUG_FREE(var) { atomic_fetch_sub(&var, 1); }
+#else
+#define DEBUG_ALLOC(var) { }
+#define DEBUG_FREE(var) { }
+#endif
+
+extern atomic_int	mem_con;
+extern atomic_int	mem_err_stream;
+extern atomic_int	mem_eval_threads;
+extern atomic_int	mem_header;
+extern atomic_int	mem_hook;
+extern atomic_int	mem_hook_pattern;
+extern atomic_int	mem_http_slot;
+extern atomic_int	mem_log_entry;
+extern atomic_int	mem_log_what;
+extern atomic_int	mem_mime_slot;
+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_qitem;
+extern atomic_int	mem_queue_item;
+extern atomic_int	mem_rack_logger;
+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();
+
+#endif /* __AGOO_DEBUG_H__ */

data/ext/agoo/error_stream.c

@@ -1,6 +1,7 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
 #include "error_stream.h"
+#include "debug.h"
 #include "text.h"
 
 static VALUE	es_class = Qundef;
@@ -14,6 +15,8 @@ static void
 es_free(void *ptr) {
     ErrorStream	es = (ErrorStream)ptr;
 
+    DEBUG_FREE(mem_err_stream)
+    DEBUG_FREE(mem_text)
     free(es->text); // allocated with malloc
     xfree(ptr);
 }
@@ -22,6 +25,7 @@ VALUE
 error_stream_new(Server server) {
     ErrorStream	es = ALLOC(struct _ErrorStream);
 
+    DEBUG_ALLOC(mem_err_stream)
     es->text = text_allocate(1024);
     es->server = server;
     

data/ext/agoo/hook.c

@@ -3,6 +3,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "debug.h"
 #include "hook.h"
 
 Hook
@@ -10,6 +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)
 	if (NULL == pattern) {
 	    pattern = "";
 	}
@@ -17,6 +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)
 	hook->method = method;
 	if (rb_respond_to(handler, rb_intern("on_request"))) {
 	    hook->type = BASE_HOOK;
@@ -36,6 +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)
     free(hook->pattern);
     free(hook);
 }

data/ext/agoo/http.c

@@ -6,6 +6,7 @@
 
 #include <ruby.h>
 
+#include "debug.h"
 #include "http.h"
 
 #define BUCKET_SIZE	1024
@@ -470,6 +471,7 @@ key_set(const char *key) {
     Slot	s;
     
     if (NULL != (s = (Slot)malloc(sizeof(struct _Slot)))) {
+	DEBUG_ALLOC(mem_http_slot)
 	s->hash = h;
 	s->klen = len;
 	s->key = key;
@@ -497,6 +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)
 	    free(s);
 	}
 	*sp = NULL;

data/ext/agoo/log.c

@@ -8,6 +8,7 @@
 #include <sys/types.h>
 #include <time.h>
 
+#include "debug.h"
 #include "dtime.h"
 #include "log.h"
 
@@ -231,6 +232,7 @@ loop(void *ctx) {
 	    }
 	    if (NULL != e->whatp) {
 		free(e->whatp);
+		DEBUG_FREE(mem_log_what)
 	    }
 	    e->ready = false;
 	}
@@ -364,6 +366,8 @@ log_init(Err err, Log log, VALUE cfg) {
 	}
     }
     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);
@@ -393,6 +397,7 @@ log_close(Log log) {
 	fclose(log->file);
 	log->file = NULL;
     }
+    DEBUG_FREE(mem_log_entry)
     free(log->q);
     log->q = NULL;
     log->end = NULL;
@@ -468,6 +473,8 @@ log_catv(LogCat cat, const char *fmt, va_list ap) {
 	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)
+    
 	    if (NULL != e->whatp) {
 		vsnprintf(e->whatp, cnt + 1, fmt, ap2);
 	    }

data/ext/agoo/page.c

@@ -7,6 +7,7 @@
 
 #include <ruby.h>
 
+#include "debug.h"
 #include "dtime.h"
 #include "page.h"
 
@@ -158,6 +159,7 @@ mime_set(Cache cache, const char *key, const char *value) {
 	    ((0 <= len && len <= MAX_KEY_UNIQ) || 0 == strcmp(s->key, key))) {
 	    if (h == (int64_t)s->hash && len == s->klen &&
 		((0 <= len && len <= MAX_KEY_UNIQ) || 0 == strcmp(s->key, key))) {
+		DEBUG_FREE(mem_mime_slot)
 		free(s->value);
 		s->value = strdup(value);
 		return;
@@ -167,6 +169,7 @@ mime_set(Cache cache, const char *key, const char *value) {
     if (NULL == (s = (MimeSlot)malloc(sizeof(struct _MimeSlot)))) {
 	rb_raise(rb_eArgError, "out of memory adding %s", key);
     }
+    DEBUG_ALLOC(mem_mime_slot)
     s->hash = h;
     s->klen = len;
     if (NULL == key) {
@@ -206,6 +209,7 @@ cache_set(Cache cache, const char *key, int klen, Page value) {
     if (NULL == (s = (Slot)malloc(sizeof(struct _Slot)))) {
 	return value;
     }
+    DEBUG_ALLOC(mem_page_slot)
     s->hash = h;
     s->klen = len;
     if (NULL == key) {
@@ -243,6 +247,7 @@ cache_destroy(Cache cache) {
     for (i = PAGE_BUCKET_SIZE; 0 < i; i--, sp++) {
 	for (s = *sp; NULL != s; s = n) {
 	    n = s->next;
+	    DEBUG_FREE(mem_page_slot)
 	    free(s);
 	}
 	*sp = NULL;
@@ -251,10 +256,12 @@ cache_destroy(Cache cache) {
     for (i = MIME_BUCKET_SIZE; 0 < i; i--, mp++) {
 	for (sm = *mp; NULL != sm; sm = m) {
 	    m = sm->next;
+	    DEBUG_FREE(mem_page_slot)
 	    free(sm);
 	}
 	*mp = NULL;
     }
+    //DEBUG_FREE(mem_cache)
     free(cache);
 }
 
@@ -265,11 +272,13 @@ page_create(const char *path) {
     Page	p = (Page)malloc(sizeof(struct _Page));
 
     if (NULL != p) {
+	DEBUG_ALLOC(mem_page)
 	p->resp = NULL;
 	if (NULL == path) {
 	    p->path = NULL;
 	} else {
 	    p->path = strdup(path);
+	    DEBUG_ALLOC(mem_page_path)
 	}
 	p->mtime = 0;
 	p->last_check = 0.0;
@@ -283,6 +292,8 @@ page_destroy(Page p) {
 	text_release(p->resp);
 	p->resp = NULL;
     }
+    DEBUG_FREE(mem_page_path)
+    DEBUG_FREE(mem_page)
     free(p->path);
     free(p);
 }
@@ -362,11 +373,13 @@ update_contents(Cache cache, Page p) {
     if (NULL == (msg = (char*)malloc(msize))) {
 	return false;
     }
+    DEBUG_ALLOC(mem_page_msg)
     cnt = sprintf(msg, page_fmt, mime, size);
 
     msize = cnt + size;
     if (size != (long)fread(msg + cnt, 1, size, f)) {
 	fclose(f);
+	DEBUG_FREE(mem_page_msg)
 	free(msg);
 	return false;
     }

data/ext/agoo/queue.c

@@ -8,6 +8,7 @@
 #include <unistd.h>
 #include <pthread.h>
 
+#include "debug.h"
 #include "dtime.h"
 #include "queue.h"
 
@@ -34,6 +35,7 @@ queue_multi_init(Queue q, size_t qsize, bool multi_push, bool multi_pop) {
 	qsize = 4;
     }
     q->q = (QItem*)malloc(sizeof(QItem) * qsize);
+    DEBUG_ALLOC(mem_qitem)
     q->end = q->q + qsize;
 
     memset(q->q, 0, sizeof(QItem) * qsize);
@@ -51,6 +53,7 @@ queue_multi_init(Queue q, size_t qsize, bool multi_push, bool multi_pop) {
 
 void
 queue_cleanup(Queue q) {
+    DEBUG_FREE(mem_qitem)
     free(q->q);
     q->q = NULL;
     q->end = NULL;

data/ext/agoo/rack_logger.c

@@ -3,6 +3,7 @@
 #include <stdlib.h>
 
 #include "rack_logger.h"
+#include "debug.h"
 #include "log.h"
 #include "text.h"
 
@@ -12,13 +13,21 @@ typedef struct _RackLogger {
     Server	server;
 } *RackLogger;
 
+static void
+rack_logger_free(void *ptr) {
+    DEBUG_FREE(mem_rack_logger)
+    xfree(ptr);
+}
+
 VALUE
 rack_logger_new(Server server) {
     RackLogger	rl = ALLOC(struct _RackLogger);
 
+    DEBUG_ALLOC(mem_rack_logger)
     rl->server = server;
     
-    return Data_Wrap_Struct(rl_class, NULL, xfree, rl);
+    //return Data_Wrap_Struct(rl_class, NULL, xfree, rl);
+    return Data_Wrap_Struct(rl_class, NULL, rack_logger_free, rl);
 }
 
 static void

data/ext/agoo/request.c

@@ -2,6 +2,7 @@
 
 #include <stdio.h>
 
+#include "debug.h"
 #include "con.h"
 #include "error_stream.h"
 #include "rack_logger.h"
@@ -517,8 +518,15 @@ to_s(VALUE self) {
     return rb_funcall(h, rb_intern("to_s"), 0);
 }
 
+void
+request_destroy(Req req) {
+    DEBUG_FREE(mem_req)
+    free(req);
+}
+
 VALUE
 request_wrap(Req req) {
+    // freed from the C side of things
     return Data_Wrap_Struct(req_class, NULL, NULL, req);
 }
 

data/ext/agoo/request.h

@@ -32,5 +32,6 @@ typedef struct _Req {
 extern void	request_init(VALUE mod);
 extern VALUE	request_wrap(Req req);
 extern VALUE	request_env(Req req);
+extern void	request_destroy(Req req);
 
 #endif // __AGOO_REQUEST_H__

data/ext/agoo/res.c

@@ -2,6 +2,7 @@
 
 #include <stdlib.h>
 
+#include "debug.h"
 #include "res.h"
 
 Res
@@ -9,6 +10,7 @@ res_create() {
     Res	res = (Res)malloc(sizeof(struct _Res));
 
     if (NULL != res) {
+	DEBUG_ALLOC(mem_res)
 	res->next = NULL;
 	atomic_init(&res->message, NULL);
 	res->close = false;
@@ -24,6 +26,7 @@ res_destroy(Res res) {
 	if (NULL != message) {
 	    text_release(message);
 	}
+	DEBUG_FREE(mem_res)
 	free(res);
     }
 }

data/ext/agoo/response.c

@@ -2,6 +2,7 @@
 
 #include <stdlib.h>
 
+#include "debug.h"
 #include "http.h"
 #include "response.h"
 #include "text.h"
@@ -51,8 +52,11 @@ response_free(void *ptr) {
 
     while (NULL != (h = res->headers)) {
 	res->headers = h->next;
+	DEBUG_FREE(mem_header)
 	xfree(h);
     }
+    DEBUG_FREE(mem_res_body);
+    DEBUG_FREE(mem_response);
     free(res->body); // allocated with strdup
     xfree(ptr);
 }
@@ -61,6 +65,7 @@ VALUE
 response_new(Server server ) {
     Response	res = ALLOC(struct _Response);
 
+    DEBUG_ALLOC(mem_response)
     memset(res, 0, sizeof(struct _Response));
     res->code = 200;
     res->server = server;
@@ -80,6 +85,7 @@ to_s(VALUE self) {
     int		len = response_len(res);
     char	*s = ALLOC_N(char, len + 1);
 
+    DEBUG_ALLOC(mem_to_s)
     response_fill(res, s);
     
     return rb_str_new(s, len);
@@ -127,6 +133,7 @@ body_set(VALUE self, VALUE val) {
 
     if (T_STRING == rb_type(val)) {
 	res->body = strdup(StringValuePtr(val));
+	DEBUG_ALLOC(mem_res_body)
 	res->blen = (int)RSTRING_LEN(val);
     } else {
 	// TBD use Oj
@@ -208,6 +215,7 @@ head_set(VALUE self, VALUE key, VALUE val) {
 	    } else {
 		prev->next = h->next;
 	    }
+	    DEBUG_FREE(mem_header)
 	    xfree(h);
 	    break;
 	}
@@ -224,6 +232,8 @@ head_set(VALUE self, VALUE key, VALUE val) {
     }
     hlen = klen + vlen + 4;
     h = (Header)ALLOC_N(char, sizeof(struct _Header) - 8 + hlen + 1);
+    DEBUG_ALLOC(mem_header)
+
     h->next = NULL;
     h->len = hlen;
     strncpy(h->text, ks, klen);

data/ext/agoo/server.c

@@ -21,6 +21,7 @@
 #include <ruby/thread.h>
 
 #include "con.h"
+#include "debug.h"
 #include "dtime.h"
 #include "err.h"
 #include "http.h"
@@ -74,6 +75,7 @@ shutdown_server(Server server) {
 		}
 		dsleep(0.02);
 	    }
+	    DEBUG_FREE(mem_eval_threads)
 	    xfree(server->eval_threads);
 	    server->eval_threads = NULL;
 	}
@@ -85,6 +87,7 @@ shutdown_server(Server server) {
 	}
 	queue_cleanup(&server->eval_queue);
 	log_close(&server->log);
+	debug_print_stats();    
     }
 }
 
@@ -105,6 +108,7 @@ server_free(void *ptr) {
     //to be pointing at it even though they have exited so live with a memory
     //leak that only shows up when the program exits.
     //xfree(ptr);
+    DEBUG_FREE(mem_server)
     the_server = NULL;
 }
 
@@ -193,7 +197,6 @@ configure(Err err, Server s, int port, const char *root, VALUE options) {
  *
  *   - *:pedantic* [_true_|_false_] if true response header and status codes are check and an exception raised if they violate the rack spec at https://github.com/rack/rack/blob/master/SPEC, https://tools.ietf.org/html/rfc3875#section-4.1.18, or https://tools.ietf.org/html/rfc7230.
  *
- *
  *   - *:thread_count* [_Integer_] number of ruby worker threads. Defaults to one. If zero then the _start_ function will not return but instead will proess using the thread that called _start_. Usually the default is best unless the workers are making IO calls.
  *
  *   - *:log_dir* [_String_] directory to place log files in. If nil or empty then no log files are written.
@@ -232,9 +235,11 @@ server_new(int argc, VALUE *argv, VALUE self) {
 	options = argv[2];
     }
     s = ALLOC(struct _Server);
+    DEBUG_ALLOC(mem_server)
     memset(s, 0, sizeof(struct _Server));
     if (ERR_OK != configure(&err, s, port, root, options)) {
 	xfree(s);
+	DEBUG_FREE(mem_server)
 	// TBD raise Agoo specific exception
 	rb_raise(rb_eArgError, "%s", err.msg);
     }
@@ -542,9 +547,10 @@ handle_rack(void *x) {
     // Disable GC. The handle_rack function or rather the env seems to get
     // collected even though it is volatile so for now turn off GC
     // temporarily.
-    rb_gc_disable();
+    //rb_gc_disable();
     rb_rescue2(handle_rack_inner, (VALUE)x, rescue_error, (VALUE)x, rb_eException, 0);
-    rb_gc_enable();
+    //rb_gc_enable();
+    //rb_gc();
 
     return NULL;
 }
@@ -604,6 +610,8 @@ process_loop(void *ptr) {
     while (server->active) {
 	if (NULL != (req = (Req)queue_pop(&server->eval_queue, 0.1))) {
 	    handle_protected(req);
+	    free(req);
+	    DEBUG_FREE(mem_req)
 	}
     }
     atomic_fetch_sub(&server->running, 1);
@@ -679,10 +687,14 @@ start(VALUE self) {
 		    break;
 		}
 		}
+		free(req);
+		DEBUG_FREE(mem_req)
 	    }
 	}
     } else {
 	server->eval_threads = ALLOC_N(VALUE, server->thread_cnt + 1);
+	DEBUG_ALLOC(mem_eval_threads)
+
 	for (i = server->thread_cnt, vp = server->eval_threads; 0 < i; i--, vp++) {
 	    *vp = rb_thread_create(wrap_process_loop, server);
 	}

data/ext/agoo/text.c

@@ -1,8 +1,10 @@
 // Copyright 2016, 2018 by Peter Ohler, All Rights Reserved
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "debug.h"
 #include "text.h"
 
 Text
@@ -10,6 +12,7 @@ text_create(const char *str, int len) {
     Text	t = (Text)malloc(sizeof(struct _Text) - TEXT_MIN_SIZE + len + 1);
 
     if (NULL != t) {
+	DEBUG_ALLOC(mem_text)
 	t->len = len;
 	t->alen = len;
 	atomic_init(&t->ref_cnt, 0);
@@ -24,6 +27,7 @@ text_allocate(int len) {
     Text	t = (Text)malloc(sizeof(struct _Text) - TEXT_MIN_SIZE + len + 1);
 
     if (NULL != t) {
+	DEBUG_ALLOC(mem_text)
 	t->len = 0;
 	t->alen = len;
 	atomic_init(&t->ref_cnt, 0);
@@ -40,6 +44,7 @@ text_ref(Text t) {
 void
 text_release(Text t) {
     if (1 >= atomic_fetch_sub(&t->ref_cnt, 1)) {
+	DEBUG_FREE(mem_text)
 	free(t);
     }
 }
@@ -56,6 +61,7 @@ text_append(Text t, const char *s, int len) {
 	if (NULL == (t = (Text)realloc(t, size))) {
 	    return NULL;
 	}
+	DEBUG_ALLOC(mem_text)
 	t->alen = new_len;
     }
     memcpy(t->text + t->len, s, len);

data/lib/agoo/version.rb

@@ -1,5 +1,5 @@
 
 module Agoo
   # Agoo version.
-  VERSION = '1.2.1'
+  VERSION = '1.2.2'
 end

data/lib/rack/handler/agoo.rb

@@ -18,7 +18,7 @@ module Rack
 
 	default_handler = handler unless handler.nil?
 	options.each { |k,v|
-	  if :port == k
+	  if :port == k || :p == k
 	    port = v.to_i
 	    options.delete(k)
 	  elsif :root == k
@@ -47,3 +47,10 @@ module Rack
     end
   end
 end
+
+begin
+  ::Rack::Handler.register('agoo', 'Rack::Handler::Agoo')
+  ::Rack::Handler.register('Agoo', 'Rack::Handler::Agoo')
+rescue Exception
+  # Rack or Rack::Handler.register has not been required.
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: agoo
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-16 00:00:00.000000000 Z
+date: 2018-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -45,6 +45,8 @@ files:
 - ext/agoo/agoo.c
 - ext/agoo/con.c
 - ext/agoo/con.h
+- ext/agoo/debug.c
+- ext/agoo/debug.h
 - ext/agoo/dtime.c
 - ext/agoo/dtime.h
 - ext/agoo/err.c