diff --git a/lib/http.js b/lib/http.js
index 40ebb22d30d..e373166f6cc 100644
--- a/lib/http.js
+++ b/lib/http.js
@@ -597,7 +597,6 @@ OutgoingMessage.prototype.end = function(data, encoding) {
   }
 
   this.finished = true;
-  DTRACE_HTTP_SERVER_RESPONSE(this.connection);
 
   // There is the first message on the outgoing queue, and we've sent
   // everything to the socket.
@@ -611,6 +610,13 @@ OutgoingMessage.prototype.end = function(data, encoding) {
 
 
 OutgoingMessage.prototype._finish = function() {
+  assert(this.connection);
+  if (this instanceof ServerResponse) {
+    DTRACE_HTTP_SERVER_RESPONSE(this.connection);
+  } else {
+    assert(this instanceof ClientRequest);
+    DTRACE_HTTP_CLIENT_REQUEST(this, this.connection);
+  }
   this.emit('finish');
 };
 
@@ -1152,6 +1158,7 @@ Agent.prototype._establishNewConnection = function() {
       self._cycle();
     });
 
+    DTRACE_HTTP_CLIENT_RESPONSE(socket, self);
     req.emit('response', res);
 
     return isHeadResponse;
@@ -1406,6 +1413,7 @@ Client.prototype._initParser = function() {
       self._cycle();
     });
 
+    DTRACE_HTTP_CLIENT_RESPONSE(self, self);
     req.emit('response', res);
 
     return isHeadResponse;
@@ -1428,7 +1436,9 @@ Client.prototype._cycle = function() {
           this._httpMessage._flush();
         } else {
           var req = this._outgoing.shift();
-          if (req) req.assignSocket(this);
+          if (req) {
+            req.assignSocket(this);
+          }
         }
       }
       break;
diff --git a/lib/net.js b/lib/net.js
index 43cfb0f74c4..d298e9a8e1a 100644
--- a/lib/net.js
+++ b/lib/net.js
@@ -346,6 +346,7 @@ Socket.prototype.write = function(data /* [encoding], [fd], [cb] */) {
     }
 
     this._onBufferChange();
+    DTRACE_NET_SOCKET_WRITE(this, 0);
 
     return false;
   } else {
@@ -426,6 +427,7 @@ Socket.prototype._writeOut = function(data, encoding, fd, cb) {
 
   try {
     bytesWritten = this._writeImpl(buffer, off, len, fd, 0);
+    DTRACE_NET_SOCKET_WRITE(this, bytesWritten);
   } catch (e) {
     this.destroy(e);
     return false;
@@ -608,6 +610,7 @@ Socket.prototype._onReadable = function() {
     bytesRead = self._readImpl(pool,
                                pool.used,
                                pool.length - pool.used);
+    DTRACE_NET_SOCKET_READ(this, bytesRead);
   } catch (e) {
     self.destroy(e);
     return;
diff --git a/src/node.cc b/src/node.cc
index ea55aa795c4..01bd5613ed5 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -2057,7 +2057,9 @@ static void Load(int argc, char *argv[]) {
   Local<Object> global = v8::Context::GetCurrent()->Global();
   Local<Value> args[1] = { Local<Value>::New(process) };
 
+#ifdef HAVE_DTRACE
   InitDTrace(global);
+#endif
 
   f->Call(global, 1, args);
 
diff --git a/src/node.d b/src/node.d
index 80010e9b4f7..bc52adf6988 100644
--- a/src/node.d
+++ b/src/node.d
@@ -10,18 +10,21 @@ typedef struct {
 	int32_t fd;
 	int32_t port;
 	uint32_t remote;
+	uint32_t buffered;
 } node_dtrace_connection_t;
 
 typedef struct {
 	int32_t fd;
 	int32_t port;
 	uint64_t remote;
+	uint32_t buffered;
 } node_dtrace_connection64_t;
 
 typedef struct {
 	int fd;
 	string remoteAddress;
 	int remotePort;
+	int bufferSize;
 } node_connection_t;
 
 translator node_connection_t <node_dtrace_connection_t *nc> {
@@ -33,6 +36,10 @@ translator node_connection_t <node_dtrace_connection_t *nc> {
 	    sizeof (int32_t))) :
 	    copyinstr((uintptr_t)*(uint64_t *)copyin((uintptr_t)
 	    &((node_dtrace_connection64_t *)nc)->remote, sizeof (int64_t)));
+	bufferSize = curpsinfo->pr_dmodel == PR_MODEL_ILP32 ?
+	    *(uint32_t *)copyin((uintptr_t)&nc->buffered, sizeof (int32_t)) :
+	    *(uint32_t *)copyin((uintptr_t)
+	    &((node_dtrace_connection64_t *)nc)->buffered, sizeof (int32_t));
 };
 
 typedef struct {
diff --git a/src/node_dtrace.cc b/src/node_dtrace.cc
index 0f7726a6209..ca7495e2f75 100644
--- a/src/node_dtrace.cc
+++ b/src/node_dtrace.cc
@@ -7,10 +7,20 @@
 #define NODE_HTTP_SERVER_REQUEST_ENABLED() (0)
 #define NODE_HTTP_SERVER_RESPONSE(arg0)
 #define NODE_HTTP_SERVER_RESPONSE_ENABLED() (0)
+#define NODE_HTTP_CLIENT_REQUEST(arg0, arg1)
+#define NODE_HTTP_CLIENT_REQUEST_ENABLED() (0)
+#define NODE_HTTP_CLIENT_RESPONSE(arg0)
+#define NODE_HTTP_CLIENT_RESPONSE_ENABLED() (0)
 #define NODE_NET_SERVER_CONNECTION(arg0)
 #define NODE_NET_SERVER_CONNECTION_ENABLED() (0)
 #define NODE_NET_STREAM_END(arg0)
 #define NODE_NET_STREAM_END_ENABLED() (0)
+#define NODE_NET_SOCKET_READ(arg0, arg1)
+#define NODE_NET_SOCKET_READ_ENABLED() (0)
+#define NODE_NET_SOCKET_WRITE(arg0, arg1)
+#define NODE_NET_SOCKET_WRITE_ENABLED() (0)
+#define NODE_GC_START(arg0, arg1)
+#define NODE_GC_DONE(arg0, arg1)
 #endif
 
 namespace node {
@@ -18,19 +28,69 @@ namespace node {
 using namespace v8;
 
 #define SLURP_STRING(obj, member, valp) \
+  if (!(obj)->IsObject()) { \
+    return (ThrowException(Exception::Error(String::New("expected " \
+      "object for " #obj " to contain string member " #member)))); \
+  } \
   String::Utf8Value _##member(obj->Get(String::New(#member))->ToString()); \
   if ((*(const char **)valp = *_##member) == NULL) \
     *(const char **)valp = "<unknown>";
 
 #define SLURP_INT(obj, member, valp) \
+  if (!(obj)->IsObject()) { \
+    return (ThrowException(Exception::Error(String::New("expected " \
+      "object for " #obj " to contain integer member " #member)))); \
+  } \
   *valp = obj->Get(String::New(#member))->ToInteger()->Value();
 
+#define SLURP_OBJECT(obj, member, valp) \
+  if (!(obj)->IsObject()) { \
+    return (ThrowException(Exception::Error(String::New("expected " \
+      "object for " #obj " to contain object member " #member)))); \
+  } \
+  *valp = Local<Object>::Cast(obj->Get(String::New(#member)));
+
 #define SLURP_CONNECTION(arg, conn) \
+  if (!(arg)->IsObject()) { \
+    return (ThrowException(Exception::Error(String::New("expected " \
+      "argument " #arg " to be a connection object")))); \
+  } \
   node_dtrace_connection_t conn; \
   Local<Object> _##conn = Local<Object>::Cast(arg); \
   SLURP_INT(_##conn, fd, &conn.fd); \
   SLURP_STRING(_##conn, remoteAddress, &conn.remote); \
-  SLURP_INT(_##conn, remotePort, &conn.port);
+  SLURP_INT(_##conn, remotePort, &conn.port); \
+  SLURP_INT(_##conn, bufferSize, &conn.buffered);
+
+#define SLURP_CONNECTION_HTTP_CLIENT(arg, conn) \
+  if (!(arg)->IsObject()) { \
+    return (ThrowException(Exception::Error(String::New("expected " \
+      "argument " #arg " to be a connection object")))); \
+  } \
+  node_dtrace_connection_t conn; \
+  Local<Object> _##conn = Local<Object>::Cast(arg); \
+  SLURP_INT(_##conn, fd, &conn.fd); \
+  SLURP_STRING(_##conn, host, &conn.remote); \
+  SLURP_INT(_##conn, port, &conn.port); \
+  SLURP_INT(_##conn, bufferSize, &conn.buffered);
+
+#define SLURP_CONNECTION_HTTP_CLIENT_RESPONSE(arg0, arg1, conn) \
+  if (!(arg0)->IsObject()) { \
+    return (ThrowException(Exception::Error(String::New("expected " \
+      "argument " #arg0 " to be a connection object")))); \
+  } \
+  if (!(arg1)->IsObject()) { \
+    return (ThrowException(Exception::Error(String::New("expected " \
+      "argument " #arg1 " to be a connection object")))); \
+  } \
+  node_dtrace_connection_t conn; \
+  Local<Object> _##conn = Local<Object>::Cast(arg0); \
+  SLURP_INT(_##conn, fd, &conn.fd); \
+  SLURP_INT(_##conn, bufferSize, &conn.buffered); \
+  _##conn = Local<Object>::Cast(arg1); \
+  SLURP_STRING(_##conn, host, &conn.remote); \
+  SLURP_INT(_##conn, port, &conn.port);
+
 
 Handle<Value> DTRACE_NET_SERVER_CONNECTION(const Arguments& args) {
   if (!NODE_NET_SERVER_CONNECTION_ENABLED())
@@ -56,6 +116,48 @@ Handle<Value> DTRACE_NET_STREAM_END(const Arguments& args) {
   return Undefined();
 }
 
+Handle<Value> DTRACE_NET_SOCKET_READ(const Arguments& args) {
+  if (!NODE_NET_SOCKET_READ_ENABLED())
+    return Undefined();
+
+  HandleScope scope;
+  int nbytes;
+
+  SLURP_CONNECTION(args[0], conn);
+
+  if (!args[1]->IsNumber()) {
+    return (ThrowException(Exception::Error(String::New("expected " 
+      "argument 1 to be number of bytes"))));
+  }
+
+  nbytes = args[1]->Int32Value();
+
+  NODE_NET_SOCKET_READ(&conn, nbytes);
+
+  return Undefined();
+}
+
+Handle<Value> DTRACE_NET_SOCKET_WRITE(const Arguments& args) {
+  if (!NODE_NET_SOCKET_WRITE_ENABLED())
+    return Undefined();
+
+  HandleScope scope;
+  int nbytes;
+
+  SLURP_CONNECTION(args[0], conn);
+
+  if (!args[1]->IsNumber()) {
+    return (ThrowException(Exception::Error(String::New("expected " 
+      "argument 1 to be number of bytes"))));
+  }
+
+  nbytes = args[1]->Int32Value();
+
+  NODE_NET_SOCKET_WRITE(&conn, nbytes);
+
+  return Undefined();
+}
+
 Handle<Value> DTRACE_HTTP_SERVER_REQUEST(const Arguments& args) {
   node_dtrace_http_request_t req;
 
@@ -65,7 +167,6 @@ Handle<Value> DTRACE_HTTP_SERVER_REQUEST(const Arguments& args) {
   HandleScope scope;
 
   Local<Object> arg0 = Local<Object>::Cast(args[0]);
-  Local<Object> arg1 = Local<Object>::Cast(args[1]);
 
   SLURP_STRING(arg0, url, &req.url);
   SLURP_STRING(arg0, method, &req.method);
@@ -88,8 +189,72 @@ Handle<Value> DTRACE_HTTP_SERVER_RESPONSE(const Arguments& args) {
   return Undefined();
 }
 
+Handle<Value> DTRACE_HTTP_CLIENT_REQUEST(const Arguments& args) {
+  node_dtrace_http_request_t req;
+  char *header;
+
+  if (!NODE_HTTP_CLIENT_REQUEST_ENABLED())
+    return Undefined();
+
+  HandleScope scope;
+
+  /*
+   * For the method and URL, we're going to dig them out of the header.  This
+   * is not as efficient as it could be, but we would rather not force the
+   * caller here to retain their method and URL until the time at which
+   * DTRACE_HTTP_CLIENT_REQUEST can be called.
+   */
+  Local<Object> arg0 = Local<Object>::Cast(args[0]);
+  SLURP_STRING(arg0, _header, &header);
+
+  req.method = header;
+
+  while (*header != '\0' && *header != ' ')
+    header++;
+
+  if (*header != '\0')
+    *header++ = '\0';
+
+  req.url = header;
+
+  while (*header != '\0' && *header != ' ')
+    header++;
+
+  *header = '\0';
+
+  SLURP_CONNECTION_HTTP_CLIENT(args[1], conn);
+  NODE_HTTP_CLIENT_REQUEST(&req, &conn);
+  return Undefined();
+}
+
+Handle<Value> DTRACE_HTTP_CLIENT_RESPONSE(const Arguments& args) {
+  if (!NODE_HTTP_CLIENT_RESPONSE_ENABLED())
+    return Undefined();
+
+  HandleScope scope;
+
+  SLURP_CONNECTION_HTTP_CLIENT_RESPONSE(args[0], args[1], conn);
+  NODE_HTTP_CLIENT_RESPONSE(&conn);
+
+  return Undefined();
+}
+
 #define NODE_PROBE(name) #name, name
 
+static int dtrace_gc_start(GCType type, GCCallbackFlags flags) {
+  NODE_GC_START(type, flags);
+  /*
+   * We avoid the tail-call elimination of the USDT probe (which screws up
+   * args) by forcing a return of 0.
+   */
+  return 0;
+}
+
+static int dtrace_gc_done(GCType type, GCCallbackFlags flags) {
+  NODE_GC_DONE(type, flags);
+  return 0;
+}
+
 void InitDTrace(Handle<Object> target) {
   static struct {
     const char *name;
@@ -98,8 +263,12 @@ void InitDTrace(Handle<Object> target) {
   } tab[] = {
     { NODE_PROBE(DTRACE_NET_SERVER_CONNECTION) },
     { NODE_PROBE(DTRACE_NET_STREAM_END) },
+    { NODE_PROBE(DTRACE_NET_SOCKET_READ) },
+    { NODE_PROBE(DTRACE_NET_SOCKET_WRITE) },
     { NODE_PROBE(DTRACE_HTTP_SERVER_REQUEST) },
     { NODE_PROBE(DTRACE_HTTP_SERVER_RESPONSE) },
+    { NODE_PROBE(DTRACE_HTTP_CLIENT_REQUEST) },
+    { NODE_PROBE(DTRACE_HTTP_CLIENT_RESPONSE) },
     { NULL }
   };
 
@@ -108,6 +277,11 @@ void InitDTrace(Handle<Object> target) {
         FunctionTemplate::New(tab[i].func));
     target->Set(String::NewSymbol(tab[i].name), tab[i].templ->GetFunction());
   }
+
+#ifdef HAVE_DTRACE
+  v8::V8::AddGCPrologueCallback((GCPrologueCallback)dtrace_gc_start);
+  v8::V8::AddGCEpilogueCallback((GCEpilogueCallback)dtrace_gc_done);
+#endif
 }
 
 }
diff --git a/src/node_dtrace.h b/src/node_dtrace.h
index 267c7292169..a3f75d0a0ac 100644
--- a/src/node_dtrace.h
+++ b/src/node_dtrace.h
@@ -10,6 +10,7 @@ typedef struct {
 	int32_t fd;
 	int32_t port;
 	char *remote;
+	int32_t buffered;
 } node_dtrace_connection_t;
 
 typedef struct {
diff --git a/src/node_provider.d b/src/node_provider.d
index 3d11f39416b..2d96114a2b3 100644
--- a/src/node_provider.d
+++ b/src/node_provider.d
@@ -30,11 +30,22 @@ provider node {
 	    (node_connection_t *c);
 	probe net__stream__end(node_dtrace_connection_t *c) :
 	    (node_connection_t *c);
+	probe net__socket__read(node_dtrace_connection_t *c, int b) :
+	    (node_connection_t *c, int b);
+	probe net__socket__write(node_dtrace_connection_t *c, int b) :
+	    (node_connection_t *c, int b);
 	probe http__server__request(node_dtrace_http_request_t *h,
 	    node_dtrace_connection_t *c) :
 	    (node_http_request_t *h, node_connection_t *c);
 	probe http__server__response(node_dtrace_connection_t *c) :
 	    (node_connection_t *c);
+	probe http__client__request(node_dtrace_http_request_t *h,
+	    node_dtrace_connection_t *c) :
+	    (node_http_request_t *h, node_connection_t *c);
+	probe http__client__response(node_dtrace_connection_t *c) :
+	    (node_connection_t *c);
+	probe gc__start(int t, int f);
+	probe gc__done(int t, int f);
 };
 
 #pragma D attributes Evolving/Evolving/ISA provider node provider
diff --git a/test/common.js b/test/common.js
index 51d5e25ae19..93a88501067 100644
--- a/test/common.js
+++ b/test/common.js
@@ -39,11 +39,15 @@ process.on('exit', function() {
                       process,
                       global];
 
-  if (DTRACE_HTTP_SERVER_RESPONSE) {
+  if (global.DTRACE_HTTP_SERVER_RESPONSE) {
     knownGlobals.push(DTRACE_HTTP_SERVER_RESPONSE);
     knownGlobals.push(DTRACE_HTTP_SERVER_REQUEST);
+    knownGlobals.push(DTRACE_HTTP_CLIENT_RESPONSE);
+    knownGlobals.push(DTRACE_HTTP_CLIENT_REQUEST);
     knownGlobals.push(DTRACE_NET_STREAM_END);
     knownGlobals.push(DTRACE_NET_SERVER_CONNECTION);
+    knownGlobals.push(DTRACE_NET_SOCKET_READ);
+    knownGlobals.push(DTRACE_NET_SOCKET_WRITE);
   }
 
   for (var x in global) {
diff --git a/wscript b/wscript
index 04591efa852..6ecd979d411 100644
--- a/wscript
+++ b/wscript
@@ -604,15 +604,20 @@ def build(bld):
   make_macros(macros_loc_default, "macro assert(x) = ;\n")
 
   if not bld.env["USE_DTRACE"]:
-    make_macros(macros_loc_default, "macro DTRACE_HTTP_SERVER_RESPONSE(x) = ;\n");
-    make_macros(macros_loc_default, "macro DTRACE_HTTP_SERVER_REQUEST(x) = ;\n");
-    make_macros(macros_loc_default, "macro DTRACE_NET_SERVER_CONNECTION(x) = ;\n");
-    make_macros(macros_loc_default, "macro DTRACE_NET_STREAM_END(x) = ;\n");
-    make_macros(macros_loc_debug, "macro DTRACE_HTTP_SERVER_RESPONSE(x) = ;\n");
-    make_macros(macros_loc_debug, "macro DTRACE_HTTP_SERVER_REQUEST(x) = ;\n");
-    make_macros(macros_loc_debug, "macro DTRACE_NET_SERVER_CONNECTION(x) = ;\n");
-    make_macros(macros_loc_debug, "macro DTRACE_NET_STREAM_END(x) = ;\n");
-
+    probes = [
+      'DTRACE_HTTP_CLIENT_REQUEST',
+      'DTRACE_HTTP_CLIENT_RESPONSE',
+      'DTRACE_HTTP_SERVER_REQUEST',
+      'DTRACE_HTTP_SERVER_RESPONSE',
+      'DTRACE_NET_SERVER_CONNECTION',
+      'DTRACE_NET_STREAM_END',
+      'DTRACE_NET_SOCKET_READ',
+      'DTRACE_NET_SOCKET_WRITE'
+    ]
+
+    for probe in probes:
+      make_macros(macros_loc_default, "macro %s(x) = ;\n" % probe)
+      make_macros(macros_loc_debug, "macro %s(x) = ;\n" % probe)
 
   def javascript_in_c(task):
     env = task.env
@@ -657,7 +662,7 @@ def build(bld):
     if bld.env["USE_DEBUG"]:
       dtrace_g = dtrace.clone("debug")
 
-    bld.install_files('/usr/lib/dtrace', 'src/node.d')
+    bld.install_files('${PREFIX}/usr/lib/dtrace', 'src/node.d')
 
     if sys.platform.startswith("sunos"):
       #