agoo 2.5.7 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf9915f94b902db5415c971deaa9b1acbcf1a293656958fe78b4b467256ce858
-  data.tar.gz: 3e6a90cff696e575faa58cd5e18af23234eedab8c0478f5ecb5ec8b385de56e4
+  metadata.gz: 2777518b8ae392fd175eb2a70e10ddc88698c8a1a7c2435fb02a210017d401ad
+  data.tar.gz: c2020e0aeca0163470c3501a0f718df32170039520d117d1b1a5b939f68840b6
 SHA512:
-  metadata.gz: 773278757468ee34167b62a2cbf41d0c35caf3240b595d5b500222045acd247273317f84fd9e25dc8b1dfbe2afce1585bbfcda360e458c15e9a28493dc078938
-  data.tar.gz: 68fadbf82b989ebc4ae2deb35209f5aff9f7d1a6a289b8d53cbab8c7930a44e93ba9515a36e15d5ed0fb9d3e6717d2c0678606c6b9c62330839b278b4e59c41b
+  metadata.gz: e60ec30b4b6f0ce6f8a5b98faf79ca5facd28bd435be0f91ebbfcf0f9ba8678e79f6fa279cc8ab7ad38b1eec99c7c76d9f171c46e377646dd9ad25df22d6c937
+  data.tar.gz: 565408d7edf87f3d6d3f26534447c98c3cd4dc545685576d36252684885e23e05c097579318dfc9b2ab6ff23fbfda5868383374c6f97b0f88b599f5e488aee25

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+### 2.6.0 - 2019-01-20
+
+GraphQL supported with a simple, easy to use API. Existing API remain the same but a new Agoo::GraphQL module has been added along with supporting examples.
+
+- Replaced the use of `gmtime` with an included function to assure support for dates before 1970.
+
 ### 2.5.7 - 2018-12-03
 
 Bad release fix along with upload example.

data/README.md

@@ -8,6 +8,8 @@ A High Performance HTTP Server for Ruby
 
 ## Usage
 
+#### Rack
+
 ```ruby
 require 'agoo'
 
@@ -29,6 +31,38 @@ Agoo::Server.start()
 # ruby hello.rb
 ```
 
+#### GraphQL
+
+```ruby
+require 'agoo'
+
+class Query
+  def hello
+    'hello'
+  end
+end
+
+class Schema
+  attr_reader :query
+
+  def initialize
+    @query = Query.new()
+  end
+end
+
+Agoo::Server.init(6464, 'root', thread_count: 1, graphql: '/graphql')
+Agoo::Server.start()
+Agoo::GraphQL.schema(Schema.new) {
+  Agoo::GraphQL.load(%^type Query { hello: String }^)
+}
+sleep
+
+# To run this GraphQL example type the following then go to a browser and enter
+# a URL of localhost:6464/graphql?query={hello}
+#
+# ruby hello.rb
+```
+
 ## Installation
 ```
 gem install agoo
@@ -54,6 +88,10 @@ Agoo is not available on Windows.
 
 ## News
 
+- Agoo has a new GraphQL module with a simple, easy to use
+  API. Checkout the [hello](example/graphql/hello.rb) or
+  [song](example/graphql/song.rb) examples.
+
 - Agoo takes first place as the highest throughput on [web-frameworks
   benchmarks](https://github.com/the-benchmarker/web-frameworks). Latency was
   not at the top but release 2.5.2 improves that. Look for an Agoo-C benchmark

data/ext/agoo/agoo.c

@@ -7,6 +7,7 @@
 
 #include "debug.h"
 #include "error_stream.h"
+#include "graphql.h"
 #include "log.h"
 #include "pub.h"
 #include "rack_logger.h"
@@ -18,6 +19,8 @@
 #include "server.h"
 #include "upgraded.h"
 
+extern void	graphql_init(VALUE mod);
+
 void
 agoo_shutdown() {
     rserver_shutdown(Qnil);
@@ -33,7 +36,9 @@ agoo_shutdown() {
 static VALUE
 ragoo_shutdown(VALUE self) {
     agoo_shutdown();
-    debug_rreport();
+    gql_destroy();
+    debug_report();
+
     return Qnil;
 }
 
@@ -74,8 +79,11 @@ ragoo_unsubscribe(VALUE self, VALUE subject) {
 
 static void
 sig_handler(int sig) {
+#ifdef MEM_DEBUG
+    rb_gc();
+#endif
     agoo_shutdown();
-
+    gql_destroy();
     debug_report();
     // Use exit instead of rb_exit as rb_exit segfaults most of the time.
     //rb_exit(0);
@@ -99,6 +107,7 @@ Init_agoo() {
     response_init(mod);
     server_init(mod);
     upgraded_init(mod);
+    graphql_init(mod);
 
     rb_define_module_function(mod, "shutdown", ragoo_shutdown, 0);
     rb_define_module_function(mod, "publish", ragoo_publish, 2);

data/ext/agoo/bind.c

@@ -15,18 +15,17 @@
 
 agooBind
 agoo_bind_port(agooErr err, int port) {
-    agooBind	b = (agooBind)malloc(sizeof(struct _agooBind));
+    agooBind	b = (agooBind)AGOO_MALLOC(sizeof(struct _agooBind));
 
     if (NULL != b) {
 	char	id[1024];
 	
-	DEBUG_ALLOC(mem_bind, b);
 	memset(b, 0, sizeof(struct _agooBind));
 	b->port = port;
 	b->family = AF_INET;
 	snprintf(id, sizeof(id) - 1, "http://:%d", port);
 	strcpy(b->scheme, "http");
-	if (NULL == (b->id = strdup(id))) {
+	if (NULL == (b->id = AGOO_STRDUP(id))) {
 	    agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of bind id failed.");
 	    return NULL;
 	}
@@ -63,17 +62,16 @@ url_tcp(agooErr err, const char *url, const char *scheme) {
 	}
 	port = atoi(colon + 1);
     }
-    if (NULL != (b = (agooBind)malloc(sizeof(struct _agooBind)))) {
+    if (NULL != (b = (agooBind)AGOO_MALLOC(sizeof(struct _agooBind)))) {
 	char	id[64];
 	
-	DEBUG_ALLOC(mem_bind, b);
 	memset(b, 0, sizeof(struct _agooBind));
 
 	b->port = port;
 	b->addr4 = addr;
 	b->family = AF_INET;
 	snprintf(id, sizeof(id), "%s://%s:%d", scheme, inet_ntoa(addr), port);
-	if (NULL == (b->id = strdup(id))) {
+	if (NULL == (b->id = AGOO_STRDUP(id))) {
 	    agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of bind id failed.");
 	    return NULL;
 	}
@@ -109,17 +107,16 @@ url_tcp6(agooErr err, const char *url, const char *scheme) {
 	agoo_err_set(err, AGOO_ERR_ARG, "%s bind address is not valid. (%s)", scheme, url);
 	return NULL;
     }
-    if (NULL != (b = (agooBind)malloc(sizeof(struct _agooBind)))) {
+    if (NULL != (b = (agooBind)AGOO_MALLOC(sizeof(struct _agooBind)))) {
 	char	str[INET6_ADDRSTRLEN + 1];
 	
-	DEBUG_ALLOC(mem_bind, b);
 	memset(b, 0, sizeof(struct _agooBind));
 
 	b->port = port;
 	b->addr6 = addr;
 	b->family = AF_INET6;
 	snprintf(buf, sizeof(buf), "%s://[%s]:%d", scheme, inet_ntop(AF_INET6, &addr, str, INET6_ADDRSTRLEN), port);
-	if (NULL == (b->id = strdup(buf))) {
+	if (NULL == (b->id = AGOO_STRDUP(buf))) {
 	    agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of bind id failed.");
 	    return NULL;
 	}	    
@@ -143,20 +140,19 @@ url_named(agooErr err, const char *url) {
 	agoo_err_set(err, AGOO_ERR_ARG, "Named Unix sockets names must not be empty.");
 	return NULL;
     } else {
-	agooBind	b = (agooBind)malloc(sizeof(struct _agooBind));
+	agooBind	b = (agooBind)AGOO_MALLOC(sizeof(struct _agooBind));
 
 	if (NULL != b) {
 	    const char	*fmt = "unix://%s";
 	    char	id[1024];
 	
-	    DEBUG_ALLOC(mem_bind, b);
 	    memset(b, 0, sizeof(struct _agooBind));
-	    if (NULL == (b->name = strdup(url))) {
+	    if (NULL == (b->name = AGOO_STRDUP(url))) {
 		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of bind url failed.");
 		return NULL;
 	    }
 	    snprintf(id, sizeof(id) - 1, fmt, url);
-	    if (NULL == (b->id = strdup(id))) {
+	    if (NULL == (b->id = AGOO_STRDUP(id))) {
 		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of bind id failed.");
 		return NULL;
 	    }
@@ -223,13 +219,12 @@ agoo_bind_url(agooErr err, const char *url) {
 
 void
 agoo_bind_destroy(agooBind b) {
-    DEBUG_FREE(mem_bind, b);
-    free(b->id);
-    free(b->name);
-    free(b->key);
-    free(b->cert);
-    free(b->ca);
-    free(b);
+    AGOO_FREE(b->id);
+    AGOO_FREE(b->name);
+    AGOO_FREE(b->key);
+    AGOO_FREE(b->cert);
+    AGOO_FREE(b->ca);
+    AGOO_FREE(b);
 }
 
 static int

data/ext/agoo/con.c

@@ -58,10 +58,9 @@ agooCon
 agoo_con_create(agooErr err, int sock, uint64_t id, agooBind b) {
     agooCon	c;
 
-    if (NULL == (c = (agooCon)malloc(sizeof(struct _agooCon)))) {
+    if (NULL == (c = (agooCon)AGOO_MALLOC(sizeof(struct _agooCon)))) {
 	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection.");
     } else {
-	DEBUG_ALLOC(mem_con, c)
 	memset(c, 0, sizeof(struct _agooCon));
 	c->sock = sock;
 	c->id = id;
@@ -74,6 +73,8 @@ agoo_con_create(agooErr err, int sock, uint64_t id, agooBind b) {
 
 void
 agoo_con_destroy(agooCon c) {
+    agooRes	res;
+
     atomic_fetch_sub(&agoo_server.con_cnt, 1);
 
     if (AGOO_CON_WS == c->bind->kind || AGOO_CON_SSE == c->bind->kind) {
@@ -91,8 +92,12 @@ agoo_con_destroy(agooCon c) {
 	c->up = NULL;
     }
     agoo_log_cat(&agoo_con_cat, "Connection %llu closed.", (unsigned long long)c->id);
-    DEBUG_FREE(mem_con, c);
-    free(c);
+
+    while (NULL != (res = c->res_head)) {
+	c->res_head = res->next;
+	AGOO_FREE(res);
+    }
+    AGOO_FREE(c);
 }
 
 const char*
@@ -789,7 +794,6 @@ con_sse_write(agooCon c) {
     ssize_t	cnt;
 
     if (NULL == message) {
-	agoo_ws_req_close(c);
 	agoo_res_destroy(res);
 
 	return false;
@@ -799,7 +803,7 @@ con_sse_write(agooCon c) {
 	agooText	t;
 	
 	if (agoo_push_cat.on) {
-	    agoo_log_cat(&agoo_push_cat, "%llu: %s", (unsigned long long)c->id, message->text);
+	    agoo_log_cat(&agoo_push_cat, "%llu: %s %p", (unsigned long long)c->id, message->text, (void*)res);
 	}
 	t = agoo_sse_expand(message);
 	if (t != message) {
@@ -817,7 +821,6 @@ con_sse_write(agooCon c) {
 	len = snprintf(msg, sizeof(msg) - 1, "Socket error @ %llu.", (unsigned long long)c->id);
 	push_error(c->up, msg, len);
 	agoo_log_cat(&agoo_error_cat, "Socket error @ %llu.", (unsigned long long)c->id);
-	agoo_ws_req_close(c);
 	
 	return false;
     }
@@ -839,13 +842,13 @@ con_sse_write(agooCon c) {
 }
 
 static void
-publish_pub(agooPub pub) {
+publish_pub(agooPub pub, agooConLoop loop) {
     agooUpgraded	up;
     const char		*sub = pub->subject->pattern;
     int			cnt = 0;
-    
+
     for (up = agoo_server.up_list; NULL != up; up = up->next) {
-	if (NULL != up->con && agoo_upgraded_match(up, sub)) {
+	if (NULL != up->con && up->con->loop == loop && agoo_upgraded_match(up, sub)) {
 	    agooRes	res = agoo_res_create(up->con);
 
 	    if (NULL != res) {
@@ -877,10 +880,10 @@ unsubscribe_pub(agooPub pub) {
 }
 
 static void
-process_pub_con(agooPub pub) {
+process_pub_con(agooPub pub, agooConLoop loop) {
     agooUpgraded	up = pub->up;
 
-    if (NULL != up) {
+    if (NULL != up && NULL != up->con && up->con->loop == loop) {
 	int	pending;
 	
 	// TBD Change pending to be based on length of con queue
@@ -901,7 +904,7 @@ process_pub_con(agooPub pub) {
 	// A close after already closed is used to decrement the reference
 	// count on the upgraded so it can be destroyed in the con loop
 	// threads.
-	if (NULL != up->con) {
+	if (NULL != up->con && up->con->loop == loop) {
 	    agooRes	res = agoo_res_create(up->con);
 
 	    if (NULL != res) {
@@ -919,7 +922,7 @@ process_pub_con(agooPub pub) {
     case AGOO_PUB_WRITE: {
 	if (NULL == up->con) {
 	    agoo_log_cat(&agoo_warn_cat, "Connection already closed. WebSocket write failed.");
-	} else {
+	} else if (up->con->loop == loop) {
 	    agooRes	res = agoo_res_create(up->con);
 
 	    if (NULL != res) {
@@ -935,14 +938,18 @@ process_pub_con(agooPub pub) {
 	}
 	break;
     case AGOO_PUB_SUB:
-	agoo_upgraded_add_subject(pub->up, pub->subject);
-	pub->subject = NULL;
+	if (NULL != up && up->con->loop == loop) {
+	    agoo_upgraded_add_subject(pub->up, pub->subject);
+	    pub->subject = NULL;
+	}
 	break;
     case AGOO_PUB_UN:
-	unsubscribe_pub(pub);
+	if (NULL != up && up->con->loop == loop) {
+	    unsubscribe_pub(pub);
+	}
 	break;
     case AGOO_PUB_MSG:
-	publish_pub(pub);
+	publish_pub(pub, loop);
 	break;
     }
     default:
@@ -1053,6 +1060,8 @@ con_ready_read(agooReady ready, void *ctx) {
 	if (!c->bind->read(c)) {
 	    return true;
 	}
+    } else {
+	return true; // not an error, just ignore
     }
     return false;
 }
@@ -1138,7 +1147,7 @@ pub_queue_ready_read(agooReady ready, void *ctx) {
 
     agoo_queue_release(&loop->pub_queue);
     while (NULL != (pub = (agooPub)agoo_queue_pop(&loop->pub_queue, 0.0))) {
-	process_pub_con(pub);
+	process_pub_con(pub, loop);
     }
     return true;
 }
@@ -1185,7 +1194,7 @@ agoo_con_loop(void *x) {
 	    }
 	}
 	while (NULL != (pub = (agooPub)agoo_queue_pop(&loop->pub_queue, 0.0))) {
-	    process_pub_con(pub);
+	    process_pub_con(pub, loop);
 	}
 	if (AGOO_ERR_OK != agoo_ready_go(&err, ready)) {
 	    agoo_log_cat(&agoo_error_cat, "IO error. %s", err.msg);
@@ -1202,12 +1211,11 @@ agooConLoop
 agoo_conloop_create(agooErr err, int id) {
      agooConLoop	loop;
 
-    if (NULL == (loop = (agooConLoop)malloc(sizeof(struct _agooConLoop)))) {
+    if (NULL == (loop = (agooConLoop)AGOO_MALLOC(sizeof(struct _agooConLoop)))) {
 	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a connection thread.");
     } else {
 	int	stat;
 	
-	//DEBUG_ALLOC(mem_con, c);
 	loop->next = NULL;
 	agoo_queue_multi_init(&loop->pub_queue, 256, true, false);
 	loop->id = id;
@@ -1229,8 +1237,7 @@ agoo_conloop_destroy(agooConLoop loop) {
     agoo_queue_cleanup(&loop->pub_queue);
     while (NULL != (res = loop->res_head)) {
 	loop->res_head = res->next;
-	DEBUG_FREE(mem_res, res);
-	free(res);
+	AGOO_FREE(res);
     }
-    free(loop);
+    AGOO_FREE(loop);
 }

data/ext/agoo/debug.c

@@ -2,213 +2,276 @@
 
 #include <pthread.h>
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-
-//#include <ruby.h>
-//#include <ruby/thread.h>
+#include <string.h>
 
 #include "debug.h"
 
 typedef struct _rec {
     struct _rec	*next;
-    void	*ptr;
-    const char	*type;
+    const void	*ptr;
+    size_t	size;
     const char	*file;
     int		line;
 } *Rec;
 
-static pthread_mutex_t	lock = PTHREAD_MUTEX_INITIALIZER;
-static Rec		recs = NULL;
-
-atomic_int	mem_bind = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_cb = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_con = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_cslot = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_err_stream = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_eval_threads = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_group = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_graphql_arg = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_graphql_directive = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_graphql_field = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_graphql_link = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_graphql_slot = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_graphql_type = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_graphql_value = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_group_path = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_header = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_hook = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_hook_pattern = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_http_slot = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_log_entry = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_log_what = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_log_tid = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_mime_slot = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_page = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_page_msg = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_page_path = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_page_slot = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_pub = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_qitem = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_queue_item = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_rack_logger = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_req = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_res = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_res_body = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_response = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_subject = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_text = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_to_s = AGOO_ATOMIC_INT_INIT(0);
-atomic_int	mem_upgraded = AGOO_ATOMIC_INT_INIT(0);
+typedef struct _rep {
+    struct _rep	*next;
+    size_t	size;
+    const char	*file;
+    int		line;
+    int		cnt;
+} *Rep;
 
 #ifdef MEM_DEBUG
-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_bind:         %d\n", mem_bind);
-    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);
-    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_log_tid:      %d\n", mem_log_tid);
-    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_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);
-    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_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
+static pthread_mutex_t	lock = PTHREAD_MUTEX_INITIALIZER;
+static Rec		recs = NULL;
+static const char	mem_pad[] = "--- This is a memory pad and should not change until being freed. ---";
 
 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
+agoo_alloc(const void *ptr, size_t size, const char *file, int line) {
+    Rec		r = (Rec)malloc(sizeof(struct _rec));
+    
+    r->ptr = ptr;
+    r->size = size;
+    r->file = file;
+    r->line = line;
+    pthread_mutex_lock(&lock);
+    r->next = recs;
+    recs = r;
+    pthread_mutex_unlock(&lock);
 }
 
-void
-debug_rreport() {
-#ifdef MEM_DEBUG
-    rb_gc_enable();
-    rb_gc();
-    print_stats();
-#endif
-}
+void*
+agoo_malloc(size_t size, const char *file, int line) {
+    void	*ptr = malloc(size + sizeof(mem_pad));
+    Rec		r = (Rec)malloc(sizeof(struct _rec));
 
-void
-debug_add(void *ptr, const char *type, const char *file, int line) {
-    Rec	r = (Rec)malloc(sizeof(struct _rec));
-    
+    strcpy(((char*)ptr) + size, mem_pad);
     r->ptr = ptr;
-    r->type = type;
+    r->size = size;
     r->file = file;
     r->line = line;
-    pthread_mutex_lock(&lock);	
+    pthread_mutex_lock(&lock);
     r->next = recs;
     recs = r;
-    pthread_mutex_unlock(&lock);	
+    pthread_mutex_unlock(&lock);
+
+    return ptr;
 }
 
-void
-debug_update(void *orig, void *ptr, const char *type, const char *file, int line) {
-    Rec	r;
+void*
+agoo_realloc(void *orig, size_t size, const char *file, int line) {
+    void	*ptr = realloc(orig, size + sizeof(mem_pad));
+    Rec		r;
     
+    strcpy(((char*)ptr) + size, mem_pad);
     pthread_mutex_lock(&lock);
     for (r = recs; NULL != r; r = r->next) {
 	if (orig == r->ptr) {
 	    r->ptr = ptr;
+	    r->size = size;
+	    r->file = file;
+	    r->line = line;
 	    break;
 	}
     }
-    pthread_mutex_unlock(&lock);	
+    pthread_mutex_unlock(&lock);
     if (NULL == r) {
 	printf("Realloc at %s:%d (%p) not allocated.\n", file, line, orig);
     }
+    return ptr;
+}
+
+char*
+agoo_strdup(const char *str, const char *file, int line) {
+    size_t	size = strlen(str) + 1;
+    char	*ptr = (char*)malloc(size + sizeof(mem_pad));
+    Rec		r = (Rec)malloc(sizeof(struct _rec));
+
+    strcpy(ptr, str);
+    strcpy(((char*)ptr) + size, mem_pad);
+    r->ptr = (void*)ptr;
+    r->size = size;
+    r->file = file;
+    r->line = line;
+    pthread_mutex_lock(&lock);
+    r->next = recs;
+    recs = r;
+    pthread_mutex_unlock(&lock);
+
+    return ptr;
+}
+
+char*
+agoo_strndup(const char *str, size_t len, const char *file, int line) {
+    size_t	size = len + 1;
+    char	*ptr = (char*)malloc(size + sizeof(mem_pad));
+    Rec		r = (Rec)malloc(sizeof(struct _rec));
+
+    memcpy(ptr, str, len);
+    ptr[len] = '\0';
+    strcpy(((char*)ptr) + size, mem_pad);
+    r->ptr = (void*)ptr;
+    r->size = size;
+    r->file = file;
+    r->line = line;
+    pthread_mutex_lock(&lock);
+    r->next = recs;
+    recs = r;
+    pthread_mutex_unlock(&lock);
+
+    return ptr;
+}
+
+void
+agoo_mem_check(void *ptr, const char *file, int line) {
+    if (NULL != ptr) {
+	Rec	r = NULL;
+    
+	pthread_mutex_lock(&lock);
+	for (r = recs; NULL != r; r = r->next) {
+	    if (ptr == r->ptr) {
+		break;
+	    }
+	}
+	pthread_mutex_unlock(&lock);
+	if (NULL == r) {
+	    printf("Memory check at %s:%d (%p) not allocated or already freed.\n", file, line, ptr);
+	} else {
+	    char	*pad = (char*)r->ptr + r->size;
+
+	    if (0 != strcmp(mem_pad, pad)) {
+		uint8_t	*p;
+		uint8_t	*end = (uint8_t*)pad + sizeof(mem_pad);
+		
+		printf("Check - Memory at %s:%d (%p) write outside allocated.\n", file, line, ptr);
+		for (p = (uint8_t*)pad; p < end; p++) {
+		    if (0x20 < *p && *p < 0x7f) {
+			printf("%c  ", *p);
+		    } else {
+			printf("%02x ", *(uint8_t*)p);
+		    }
+		}
+		printf("\n");
+	    }
+	}
+    }
 }
 
 void
-debug_del(void *ptr, const char *file, int line) {
-    Rec	r = NULL;
-    Rec	prev = NULL;
+agoo_freed(void *ptr, const char *file, int line) {
+    if (NULL != ptr) {
+	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;
+	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 {
+	    char	*pad = (char*)r->ptr + r->size;
+
+	    if (0 != strcmp(mem_pad, pad)) {
+		uint8_t	*p;
+		uint8_t	*end = (uint8_t*)pad + sizeof(mem_pad);
+		
+		printf("Memory at %s:%d (%p) write outside allocated.\n", file, line, ptr);
+		for (p = (uint8_t*)pad; p < end; p++) {
+		    if (0x20 < *p && *p < 0x7f) {
+			printf("%c  ", *p);
+		    } else {
+			printf("%02x ", *(uint8_t*)p);
+		    }
+		}
+		printf("\n");
+	    }
+	    free(r);
+	}
+    }
+}
+
+void
+agoo_free(void *ptr, const char *file, int line) {
+    if (NULL != ptr) {
+	agoo_freed(ptr, file, line);
+	free(ptr);
+    }
+}
+
+#endif
+
+#ifdef MEM_DEBUG
+
+static Rep
+update_reps(Rep reps, Rec r) {
+    Rep	rp = reps;
+
+    for (; NULL != rp; rp = rp->next) {
+	if (rp->line == r->line && (rp->file == r->file || 0 == strcmp(rp->file, r->file))) {
+	    rp->size += r->size;
+	    rp->cnt++;
 	    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);
+    if (NULL == rp) {
+	rp = (Rep)malloc(sizeof(struct _rep));
+	rp->size = r->size;
+	rp->file = r->file;
+	rp->line = r->line;
+	rp->cnt = 1;
+	rp->next = reps;
+	reps = rp;
+    }
+    return reps;
+}
+
+static void
+print_stats() {
+    printf("\n--- Memory Usage Report --------------------------------------------------------\n");
+    pthread_mutex_lock(&lock);
+
+    if (NULL == recs) {
+	printf("No memory leaks\n");
     } else {
-	free(r);
+	Rep	reps = NULL;
+	Rep	rp;
+	Rec	r;
+	size_t	leaked = 0;
+
+	for (r = recs; NULL != r; r = r->next) {
+	    reps = update_reps(reps, r);
+	}
+	while (NULL != (rp = reps)) {
+	    reps = rp->next;
+	    printf("%16s:%3d %8lu bytes over %d occurances allocated and not freed.\n", rp->file, rp->line, rp->size, rp->cnt);
+	    leaked += rp->size;
+	    free(rp);
+	}
+	printf("%lu bytes leaked\n", leaked);
     }
+    pthread_mutex_unlock(&lock);
+    printf("--------------------------------------------------------------------------------\n");
+}
+#endif
+
+void
+debug_report() {
+#ifdef MEM_DEBUG
+    print_stats();
+#endif
 }