memprof 0.3.6 → 0.3.7

data/README.md

@@ -0,0 +1,284 @@
+# memprof
+(c) Joe Damato
+@joedamato
+http://timetobleed.com
+
+Memprof is a Ruby level memory profiler that can help you find reference
+leaks in your application.
+
+Memprof can also do very lightweight function call tracing to figure out
+which system and library calls are happening in your code.
+
+# Installation
+
+    gem install memprof
+
+# API
+
+## Memprof.stats
+
+    Memprof.start
+    12.times{ "abc" }
+    Memprof.stats
+    Memprof.stop
+
+Start tracking file/line information for objects created after calling
+`Memprof.start`, and print out a summary of file:line/class pairs
+created.
+
+    12 file.rb:2:String
+
+*Note*: Call `Memprof.stats` again after `GC.start` to see which objects
+are cleaned up by the garbage collector:
+
+    Memprof.start
+    10.times{ $last_str = "abc" }
+
+    puts '=== Before GC'
+    Memprof.stats
+
+    puts '=== After GC'
+    GC.start
+    Memprof.stats
+
+    Memprof.stop
+
+After `GC.start`, only the very last instance of `"abc"` will still
+exist:
+
+    === Before GC
+         10 file.rb:2:String
+    === After GC
+          1 file.rb:2:String
+
+*Note*: Use `Memprof.stats("/path/to/file")` to write results to a file.
+
+*Note*: Use `Memprof.stats!` to clear out tracking data after printing
+out results.
+
+## Memprof.track
+
+Simple wrapper for `Memprof.stats` that will start/stop memprof around a
+given block of ruby code.
+
+    Memprof.track{
+      100.times{ "abc" }
+      100.times{ 1.23 + 1 }
+      100.times{ Module.new }
+    }
+
+For the block of ruby code, print out file:line/class pairs for
+ruby objects created.
+
+    100  file.rb:2:String
+    100  file.rb:3:Float
+    100  file.rb:4:Module
+
+*Note*: You can call GC.start at the end of the block to print out only
+objects that are 'leaking' (i.e. objects that still have inbound
+references).
+
+*Note*: Use `Memprof.track("/path/to/file")` to write the results to a
+file instead of stdout.
+
+## Memprof.dump
+
+    Memprof.dump{
+      "hello" + "world"
+    }
+
+Dump out all objects created in a given ruby block as detailed json
+objects.
+
+    {
+      "_id": "0x15e5018",
+
+      "file": "file.rb",
+      "line": 2,
+
+      "type": "string",
+      "class_name": "String",
+
+      "length": 10,
+      "data": "helloworld"
+    }
+
+*Note*: Use `Memprof.dump("/path/to/filename")` to write the json output
+to a file, one per line.
+
+## Memprof.dump_all
+
+    Memprof.dump_all("myapp_heap.json")
+
+Dump out all live objects inside the Ruby VM to `myapp_heap.json`, one
+per line.
+
+### [memprof.com](http://memprof.com) heap visualizer
+
+    # load memprof before requiring rubygems, so objects created by
+    # rubygems itself are tracked by memprof too
+    require `gem which memprof/signal`.strip
+
+    require 'rubygems'
+    require 'myapp'
+
+Installs a `URG` signal handler and starts tracking file/line
+information for newly created ruby objects. When the process receives
+`SIGURG`, it will fork and call `Memprof.dump_all` to write out the
+entire heap to a json file.
+
+Use the `memprof` command to send the signal and upload the heap to
+[memprof.com](http://memprof.com):
+
+    memprof --pid <PID> --name my_leaky_app --key <API_KEY>
+
+## Memprof.trace
+
+    require 'open-uri'
+    require 'mysql'
+    require 'memcached'
+
+    Memprof.trace{
+      10.times{ Module.new }
+      10.times{ GC.start }
+      10.times{ open('http://google.com/') }
+      10.times{ Mysql.connect.query("select 1+2") }
+      10.times{ Memcached.new.get('memprof') }
+    }
+
+For a given block of ruby code, count:
+
+ - number of objects created per type
+ - number of calls to and time spent in GC
+ - number of calls to and time spent in connect/read/write/select
+ - number of calls to and time spent in mysql queries
+ - number of calls to and responses to memcached commands
+ - number of calls to and bytes through malloc/realloc/free
+
+The resulting json report looks like:
+
+    {
+      "objects": {
+        "created": 10,
+        "types": {
+          "module": 10,  # Module.new
+        }
+      },
+
+      "gc": {
+        "calls": 10,     # GC.start
+        "time": 0.17198
+      },
+
+      "fd": {
+        "connect": {
+          "calls": 10,   # open('http://google.com')
+          "time": 0.0110
+        }
+      },
+
+      "mysql": {
+        "queries": 10,   # Mysql.connect.query("select 1+2")
+        "time": 0.0006
+      },
+
+      "memcache": {
+        "get": {
+          "calls": 10,   # Memcached.new.get('memprof')
+          "responses": {
+            "notfound": 10
+          }
+        }
+      }
+    }
+
+*Note*: To write json to a file instead, set `Memprof.trace_filename =
+"/path/to/file.json"`
+
+## Memprof.trace_request
+
+    Memprof.trace_request(env){ @app.call(env) }
+
+Like `Memprof.trace`, but assume an incoming Rack request and include
+information about the request itself.
+
+    {
+      "start" : 1272424769750716,
+      "tracers" : {
+        /* ... */
+      },
+      "rails" : {
+        "controller" : "home",
+        "action" : "index"
+      },
+      "request" : {
+        "REQUEST_URI" : "/home",
+        "REQUEST_METHOD" : "GET",
+        "REMOTE_ADDR" : "127.0.0.1",
+        "QUERY_STRING" : null
+      },
+      "time" : 1.3442
+    }
+
+# Middlewares
+
+## Memprof::Middleware
+
+    require 'memprof/middleware'
+    config.middlewares.use(Memprof::Middleware)
+
+Wrap each request in a `Memprof.track` to print out all object
+location/type pairs created during that request.
+
+*Note*: It is preferable to run this in staging or production mode with
+Rails applications, since development mode creates a lot of unnecessary
+objects during each request.
+
+*Note*: To force a GC run before printing out a report, pass in
+`:force_gc => true` to the middleware.
+
+## Memprof::Tracer
+
+    require 'memprof/tracer'
+    config.middleware.insert(0, Memprof::Tracer)
+
+Wrap each request in a `Memprof.trace_request` and write results to
+`/tmp/memprof_tracer-PID.json`
+
+## Memprof::Filter
+
+Similar to `Memprof::Tracer`, but for legacy Rails 2.2 applications.
+
+    class ApplicationController < ActionController::Base
+      require 'memprof/tracer'
+      around_filter(Memprof::Filter)
+    end
+
+# Compatibility
+
+Memprof supports all 1.8.x (MRI and REE) VMs, as long as they are 64-bit
+and contain debugging symbols. For best results, use RVM to compile ruby
+and make sure you are on a 64-bit machine.
+
+The following ruby builds are not supported:
+
+ - Ruby on small/medium EC2 instances (32-bit machines)
+ - OSX's default system ruby (no debugging symbols, fat 32/64-bit
+   binary)
+
+*Note*: Many linux distributions do not package debugging symbols by
+default. You can usually install these separately, for example using
+`apt-get install libruby1.8-dbg`
+
+## Coming soon
+
+ - support for Ruby 1.9
+ - support for i386/i686 ruby builds
+
+# Credits
+
+ - Jake Douglas for the Mach-O Snow Leopard support
+ - Aman Gupta for various bug fixes and other cleanup
+ - Rob Benson for initial 1.9 support and cleanup
+ - Paul Barry for force_gc support in `Memprof::Middleware`
+

data/ext/elf.c

@@ -51,6 +51,8 @@ struct elf_info {
   void *text_segment;
   size_t text_segment_len;
 
+  GElf_Addr got_addr;
+
   GElf_Addr relplt_addr;
   Elf_Data *relplt;
   size_t relplt_count;
@@ -129,12 +131,28 @@ struct plt_entry {
  * the entry uses.
  */
 static void *
-get_got_addr(struct plt_entry *plt)
+get_got_addr(struct plt_entry *plt, struct elf_info *info)
 {
+  void *addr = NULL;
+
   assert(plt != NULL);
-  /* the jump is relative to the start of the next instruction. */
-  dbg_printf("PLT addr: %p, .got.plt slot: %p\n", plt, (void *)&(plt->pad) + plt->jmp_disp);
-  return (void *)&(plt->pad) + plt->jmp_disp;
+  assert(plt->jmp[0] == 0xff);
+
+  if (plt->jmp[1] == 0x25) {
+#if defined(_ARCH_x86_64_)
+    // jmpq   *0x2ccf3a(%rip)
+    addr = (void *)&(plt->pad) + plt->jmp_disp;
+#else
+    // jmp    *0x81060f0
+    addr = (void *)(plt->jmp_disp);
+#endif
+  } else if (plt->jmp[1] == 0xa3) {
+    // jmp    *0x130(%ebx)
+    addr = (void *)(info->base_addr + info->got_addr + plt->jmp_disp);
+  }
+
+  dbg_printf("PLT addr: %p, .got.plt slot: %p\n", plt, addr);
+  return addr;
 }
 
 /*
@@ -144,15 +162,15 @@ get_got_addr(struct plt_entry *plt)
  * returns the original function address
  */
 static void *
-overwrite_got(void *plt, const void *tramp)
+overwrite_got(void *plt, const void *tramp, struct elf_info *info)
 {
   assert(plt != NULL);
   assert(tramp != NULL);
   void *ret = NULL;
 
-  memcpy(&ret, get_got_addr(plt), sizeof(void *));
-  copy_instructions(get_got_addr(plt), &tramp, sizeof(void *));
-  dbg_printf("GOT value overwritten to: %p\n", tramp);
+  memcpy(&ret, get_got_addr(plt, info), sizeof(void *));
+  copy_instructions(get_got_addr(plt, info), &tramp, sizeof(void *));
+  dbg_printf("GOT value overwritten to: %p, from: %p\n", tramp, ret);
   return ret;
 }
 
@@ -237,7 +255,7 @@ hook_required_objects(struct elf_info *info, void *data)
 
   if ((trampee_addr = find_plt_addr(hook_data->sym, info)) != NULL) {
     dbg_printf("found: %s @ %p\n", hook_data->sym, trampee_addr);
-    overwrite_got(trampee_addr, hook_data->addr);
+    overwrite_got(trampee_addr, hook_data->addr, info);
   }
 
   return;
@@ -282,6 +300,9 @@ do_bin_allocate_page(struct elf_info *info)
      * grab a page in the lower 4gb of the address space.
      */
     assert((size_t)info->text_segment <= UINT_MAX);
+#ifndef MAP_32BIT
+#define MAP_32BIT 0 // no MAP_32BIT defined on certain 32bit systems
+#endif
     return mmap(NULL, memprof_config.pagesize, PROT_WRITE|PROT_READ|PROT_EXEC, MAP_ANON|MAP_PRIVATE|MAP_32BIT, -1, 0);
   }
 
@@ -344,29 +365,39 @@ find_plt_addr(const char *symname, struct elf_info *info)
 
   /* Search through each of the .rela.plt entries */
   for (i = 0; i < info->relplt_count; i++) {
+    GElf_Rel rel;
     GElf_Rela rela;
     GElf_Sym sym;
     GElf_Addr addr;
-    void *ret;
+    void *ret = NULL;
     const char *name;
 
     if (info->relplt->d_type == ELF_T_RELA) {
       ret = gelf_getrela(info->relplt, i, &rela);
-
       if (ret == NULL
           || ELF64_R_SYM(rela.r_info) >= info->dynsym_count
           || gelf_getsym(info->dynsym, ELF64_R_SYM(rela.r_info), &sym) == NULL)
-        return NULL;
+        continue;
 
-      name = info->dynstr + sym.st_name;
+    } else if (info->relplt->d_type == ELF_T_REL) {
+      ret = gelf_getrel(info->relplt, i, &rel);
+      if (ret == NULL
+          || ELF64_R_SYM(rel.r_info) >= info->dynsym_count
+          || gelf_getsym(info->dynsym, ELF64_R_SYM(rel.r_info), &sym) == NULL)
+        continue;
+    } else {
+      dbg_printf("unknown relplt entry type: %d\n", info->relplt->d_type);
+      continue;
+    }
 
-      /* The name matches the name of the symbol passed in, so get the PLT entry
-       * address and return it.
-       */
-      if (strcmp(symname, name) == 0) {
-        addr = get_plt_addr(info, i);
-        return (void *)addr;
-      }
+    name = info->dynstr + sym.st_name;
+
+    /* The name matches the name of the symbol passed in, so get the PLT entry
+     * address and return it.
+     */
+    if (strcmp(symname, name) == 0) {
+      addr = get_plt_addr(info, i);
+      return (void *)addr;
     }
   }
 
@@ -426,6 +457,7 @@ do_bin_find_symbol(const char *sym, size_t *size, struct elf_info *elf)
     for (; esym < lastsym; esym++){
       /* ignore numeric/empty symbols */
       if ((esym->st_value == 0) ||
+          (elf->dynstr == 0) ||
           (ELF32_ST_BIND(esym->st_info)== STB_NUM))
         continue;
 
@@ -563,7 +595,7 @@ bin_update_image(const char *trampee, struct tramp_st2_entry *tramp, void **orig
   if (trampee_addr) {
     void *ret = NULL;
     dbg_printf("Found %s in the PLT, inserting tramp...\n", trampee);
-    ret = overwrite_got(trampee_addr, tramp->addr);
+    ret = overwrite_got(trampee_addr, tramp->addr, ruby_info);
 
     assert(ret != NULL);
 
@@ -1079,6 +1111,9 @@ dissect_elf(struct elf_info *info, int find_debug)
         if (dyn.d_tag == DT_JMPREL) {
           info->relplt_addr = dyn.d_un.d_ptr;
         }
+        else if (dyn.d_tag == DT_PLTGOT) {
+          info->got_addr = dyn.d_un.d_ptr;
+        }
         else if (dyn.d_tag == DT_PLTRELSZ) {
           info->plt_size = dyn.d_un.d_val;
         }
@@ -1108,8 +1143,8 @@ dissect_elf(struct elf_info *info, int find_debug)
 
       data = elf_getdata(scn, NULL);
       if (data == NULL || elf_getdata(scn, data) != NULL
-          || shdr.sh_size != data->d_size || data->d_off) {
-        dbg_printf("Couldn't get .dynstr data");
+          || shdr.sh_size != data->d_size) {// condition true on 32bit: || data->d_off) {
+        dbg_printf("Couldn't get .dynstr data\n");
         ret = 1;
         goto out;
       }
@@ -1132,6 +1167,8 @@ dissect_elf(struct elf_info *info, int find_debug)
     else if (shdr.sh_type == SHT_PROGBITS) {
       if (strcmp(elf_strptr(elf, shstrndx, shdr.sh_name), ".plt") == 0) {
         info->plt_addr = shdr.sh_addr;
+      } else if (strcmp(elf_strptr(elf, shstrndx, shdr.sh_name), ".got.plt") == 0) {
+        info->got_addr = shdr.sh_addr;
       } else if (strcmp(elf_strptr(elf, shstrndx, shdr.sh_name), ".gnu_debuglink") == 0) {
         dbg_printf("gnu_debuglink section found\n", shdr.sh_size);
         if ((info->debuglink_data = elf_getdata(scn, NULL)) == NULL ||
@@ -1214,9 +1251,6 @@ bin_init()
 {
   Dwarf_Error dwrf_err;
 
-  ASSERT_ON_COMPILE(sizeof(unsigned long) == sizeof(GElf_Addr));
-  ASSERT_ON_COMPILE(sizeof(unsigned long) == sizeof(Elf64_Addr));
-
   ruby_info = calloc(1, sizeof(*ruby_info));
 
   if (!ruby_info) {

data/ext/extconf.rb

@@ -186,7 +186,7 @@ if have_header('mach-o/dyld.h')
     expressions << ["address__#{name}", "&#{name}"]
   end
 
-  pid = fork{sleep}
+  pid = fork{sleep while true}
   output = IO.popen('gdb --interpreter=mi --quiet', 'w+') do |io|
     io.puts "attach #{pid}"
     expressions.each do |name, expr|

data/ext/memprof.c

@@ -346,6 +346,35 @@ memprof_track(int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
+static json_gen_status
+json_gen_id(json_gen gen, ID id)
+{
+  if (id) {
+    if (id < 100)
+      return json_gen_format(gen, ":%c", id);
+    else
+      return json_gen_format(gen, ":%s", rb_id2name(id));
+  } else
+    return json_gen_null(gen);
+}
+
+static json_gen_status
+json_gen_value(json_gen gen, VALUE obj)
+{
+  if (FIXNUM_P(obj))
+    return json_gen_integer(gen, NUM2LONG(obj));
+  else if (NIL_P(obj) || obj == Qundef)
+    return json_gen_null(gen);
+  else if (obj == Qtrue)
+    return json_gen_bool(gen, 1);
+  else if (obj == Qfalse)
+    return json_gen_bool(gen, 0);
+  else if (SYMBOL_P(obj))
+    return json_gen_id(gen, SYM2ID(obj));
+  else
+    return json_gen_pointer(gen, (void*)obj);
+}
+
 static json_gen_config fancy_conf = { .beautify = 1, .indentString = "  " };
 static json_gen_config basic_conf = { .beautify = 0, .indentString = "  " };
 
@@ -469,7 +498,7 @@ memprof_trace_request(VALUE self, VALUE env)
 
   json_gen_cstr(gen, "start");
   gettimeofday(&now, NULL);
-  json_gen_integer(gen, (now.tv_sec * 1000000) + now.tv_usec);
+  json_gen_integer(gen, (now.tv_sec * 1000) + (now.tv_usec / 1000));
 
   json_gen_cstr(gen, "tracers");
   json_gen_map_open(gen);
@@ -533,6 +562,14 @@ memprof_trace_request(VALUE self, VALUE env)
     DUMP_HASH_ENTRY("QUERY_STRING");
 
     json_gen_map_close(gen);
+
+    if (RTEST(ret) && BUILTIN_TYPE(ret) == T_ARRAY) {
+      json_gen_cstr(gen, "response");
+      json_gen_map_open(gen);
+      json_gen_cstr(gen, "code");
+      json_gen_value(gen, RARRAY_PTR(ret)[0]);
+      json_gen_map_close(gen);
+    }
   }
 
   json_gen_cstr(gen, "time");
@@ -568,35 +605,6 @@ memprof_trace_request(VALUE self, VALUE env)
 #define RSTRING_LEN(str) RSTRING(str)->len
 #endif
 
-static json_gen_status
-json_gen_id(json_gen gen, ID id)
-{
-  if (id) {
-    if (id < 100)
-      return json_gen_format(gen, ":%c", id);
-    else
-      return json_gen_format(gen, ":%s", rb_id2name(id));
-  } else
-    return json_gen_null(gen);
-}
-
-static json_gen_status
-json_gen_value(json_gen gen, VALUE obj)
-{
-  if (FIXNUM_P(obj))
-    return json_gen_integer(gen, NUM2LONG(obj));
-  else if (NIL_P(obj) || obj == Qundef)
-    return json_gen_null(gen);
-  else if (obj == Qtrue)
-    return json_gen_bool(gen, 1);
-  else if (obj == Qfalse)
-    return json_gen_bool(gen, 0);
-  else if (SYMBOL_P(obj))
-    return json_gen_id(gen, SYM2ID(obj));
-  else
-    return json_gen_pointer(gen, (void*)obj);
-}
-
 static int
 each_hash_entry(st_data_t key, st_data_t record, st_data_t arg)
 {
@@ -1942,7 +1950,9 @@ Init_memprof()
   install_objects_tracer();
   install_fd_tracer();
   install_mysql_tracer();
+  install_postgres_tracer();
   install_memcache_tracer();
+  install_resources_tracer();
 
   gc_hook = Data_Wrap_Struct(rb_cObject, sourcefile_marker, NULL, NULL);
   rb_global_variable(&gc_hook);

data/ext/tracer.h

@@ -41,6 +41,8 @@ extern void install_malloc_tracer();
 extern void install_gc_tracer();
 extern void install_fd_tracer();
 extern void install_mysql_tracer();
+extern void install_postgres_tracer();
 extern void install_objects_tracer();
 extern void install_memcache_tracer();
+extern void install_resources_tracer();
 #endif

data/ext/tracers/postgres.c

@@ -0,0 +1,73 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+
+#include "arch.h"
+#include "bin_api.h"
+#include "json.h"
+#include "tracer.h"
+#include "tramp.h"
+#include "util.h"
+
+struct memprof_postgres_stats {
+  size_t query_calls;
+};
+
+static struct tracer tracer;
+static struct memprof_postgres_stats stats;
+static void * (*orig_PQexec)(void *postgres, const char *stmt);
+
+static void *
+PQexec_tramp(void *postgres, const char *stmt) {
+  void *ret;
+
+  ret = orig_PQexec(postgres, stmt);
+  stats.query_calls++;
+
+  return ret;
+}
+
+static void
+postgres_trace_start() {
+  static int inserted = 0;
+
+  if (!inserted)
+    inserted = 1;
+  else
+    return;
+
+  orig_PQexec = bin_find_symbol("PQexec", NULL, 1);
+  if (orig_PQexec)
+    insert_tramp("PQexec", PQexec_tramp);
+}
+
+static void
+postgres_trace_stop() {
+}
+
+static void
+postgres_trace_reset() {
+  memset(&stats, 0, sizeof(stats));
+}
+
+static void
+postgres_trace_dump(json_gen gen) {
+  if (stats.query_calls > 0) {
+    json_gen_cstr(gen, "queries");
+    json_gen_integer(gen, stats.query_calls);
+  }
+}
+
+void install_postgres_tracer()
+{
+  tracer.start = postgres_trace_start;
+  tracer.stop = postgres_trace_stop;
+  tracer.reset = postgres_trace_reset;
+  tracer.dump = postgres_trace_dump;
+  tracer.id = "postgres";
+
+  trace_insert(&tracer);
+}

data/ext/tracers/resources.c

@@ -0,0 +1,89 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+
+#include "json.h"
+#include "tracer.h"
+#include "tramp.h"
+#include "util.h"
+
+struct memprof_resources_stats {
+  long nsignals;
+
+  long inblock;
+  long oublock;
+
+  double utime;
+  double stime;
+};
+
+static struct tracer tracer;
+static struct memprof_resources_stats stats;
+
+#define TVAL_TO_DBL(tv) ((double)tv.tv_sec + (double)tv.tv_usec * 1e-6)
+
+static void
+resources_trace_start() {
+  struct rusage usage;
+  getrusage(RUSAGE_SELF, &usage);
+
+  stats.nsignals = -usage.ru_nsignals;
+
+  stats.inblock = -usage.ru_inblock;
+  stats.oublock = -usage.ru_oublock;
+
+  stats.stime = -TVAL_TO_DBL(usage.ru_stime);
+  stats.utime = -TVAL_TO_DBL(usage.ru_utime);
+}
+
+static void
+resources_trace_dump(json_gen gen) {
+  { // calculate diff before dump, since stop is called after dump
+    struct rusage usage;
+    getrusage(RUSAGE_SELF, &usage);
+
+    stats.nsignals += usage.ru_nsignals;
+
+    stats.inblock += usage.ru_inblock;
+    stats.oublock += usage.ru_oublock;
+
+    stats.stime += TVAL_TO_DBL(usage.ru_stime);
+    stats.utime += TVAL_TO_DBL(usage.ru_utime);
+  }
+
+  json_gen_cstr(gen, "signals");
+  json_gen_integer(gen, stats.nsignals);
+
+  json_gen_cstr(gen, "inputs");
+  json_gen_integer(gen, stats.inblock);
+
+  json_gen_cstr(gen, "outputs");
+  json_gen_integer(gen, stats.oublock);
+
+  json_gen_cstr(gen, "stime");
+  json_gen_double(gen, stats.stime);
+
+  json_gen_cstr(gen, "utime");
+  json_gen_double(gen, stats.utime);
+}
+
+static void
+resources_trace_stop() {
+}
+
+static void
+resources_trace_reset() {
+}
+
+void install_resources_tracer()
+{
+  tracer.start = resources_trace_start;
+  tracer.stop = resources_trace_stop;
+  tracer.reset = resources_trace_reset;
+  tracer.dump = resources_trace_dump;
+  tracer.id = "resource";
+
+  trace_insert(&tracer);
+}

data/memprof.gemspec

@@ -1,7 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'memprof'
-  s.version = '0.3.6'
-  s.date = '2010-04-13'
+  s.version = '0.3.7'
   s.summary = 'Ruby Memory Profiler'
   s.description = "Ruby memory profiler similar to bleak_house, but without patches to the Ruby VM"
   s.homepage = "http://github.com/ice799/memprof"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: memprof
 version: !ruby/object:Gem::Version 
-  hash: 31
-  prerelease: false
+  hash: 29
+  prerelease: 
   segments: 
   - 0
   - 3
-  - 6
-  version: 0.3.6
+  - 7
+  version: 0.3.7
 platform: ruby
 authors: 
 - Joe Damato
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-13 00:00:00 -07:00
+date: 2011-01-28 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -64,7 +64,7 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
-- README.rdoc
+- README.md
 - Rakefile
 - bin/memprof
 - ext/arch.h
@@ -89,6 +89,8 @@ files:
 - ext/tracers/memory.c
 - ext/tracers/mysql.c
 - ext/tracers/objects.c
+- ext/tracers/postgres.c
+- ext/tracers/resources.c
 - ext/tramp.c
 - ext/tramp.h
 - ext/util.c
@@ -134,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
 summary: Ruby Memory Profiler

data/README.rdoc

@@ -1,118 +0,0 @@
-= memprof (c) Joe Damato  @joedamato   http://timetobleed.com
-
-Memprof is a Ruby level memory profiler that can help you find reference leaks in your application.
-Memprof can also do very lightweight function call tracing to help you figure out which system calls, and library calls your code causes. 
-
-== Installing
-
-  gem install memprof
-
-== Usage
-
-== Memory Tracking
-
-== Blocks (memory tracking)
-
-  Memprof.track {
-    100.times{ "abc" }
-    100.times{ 1.23 + 1 }
-    100.times{ Module.new }
-  }
-
-Outputs:
-
-  100   file.rb:2:String
-  100   file.rb:3:Float
-  100   file.rb:4:Module
-
-== Rails requests (memory tracking)
-
-Use the Memprof::Middleware
-
-== Dump objects
-
-  Memprof.dump {
-    "hello" + "world"
-  }
-
-Outputs:
-
-  {
-  "_id": "0x19c610",
-  "file": "file.rb",
-  "line": 2,
-  "type": "string",
-  "class": "0x1ba7f0",
-  "class_name": "String",
-  "length": 10,
-  "data": "helloworld"
-  }
-
-You can dump any Ruby object you want.
-
-== Dumping the entire heap
-
-  Memprof.dump_all("file.json")
-
-This will dump out every single live object as json to /tmp/file.json
-
-== Less elegant tracking usage:
-
-  require 'memprof'
-  Memprof.start
-
-  # ruby code
-
-  Memprof.stats
-
-  # more ruby code
-
-  Memprof.stats
-  Memprof.stop
-
-The above code will output 2 summaries, allowing you to compare which objects were
-destroyed and which are still around.
-
-Memprof.stats also takes an (optional) file name to write the output to a file.
-
-== Function call tracing
-
-This system is under development and the API may change without warning.
-
-You can use the middleware Memprof::Tracer to output function tracing and request information for
-each request that comes in to your app.
-
-== Compatibility
-
-You must have debug symbols installed or a an unstripped version of Ruby.
-
-To install debug symbols on Debian-like systems:
-
-  apt-get install libruby1.8-dbg
-
-Not supporting:
-  * OSX default Ruby
-  * Stripped Ruby binaries without debug symbols
-  * Any and all Windows Ruby builds
-  * Ruby 1.9+ on all systems
-  * 32bit systems
-
-Supporting:
-  * Linux (enable-shared AND disable-shared):
-    * x86_64 builds of Ruby Enterprise Edition 1.8.6/1.8.7
-    * x86_64 builds of MRI Ruby
-
-  * Snow Leopard (enable-shared AND disable-shared):
-    * x86_64 builds of Ruby Enterprise Edition 1.8.6/1.8.7
-    * x86_64 builds of MRI Ruby
-
-Coming soon:
-
-  Official support for Ruby 1.9
-  Official support for i386/i686
-
-== Special Thanks
-  * Jake Douglas for the Mach O/snow leopard support.
-  * Aman Gupta for various bug fixes and other cleanup.
-  * Rob Benson for 1.9 support and cleanup.
-  * Paul Barry for force_gc support in Memprof::Middleware