diff --git a/api/zyre_event.xml b/api/zyre_event.xml
index 1781148e3..aa9accef9 100644
--- a/api/zyre_event.xml
+++ b/api/zyre_event.xml
@@ -38,17 +38,17 @@
         <return type = "enum:zyre event.type" />
     </method>
 
-    <method name = "sender">
-        Return the sending peer's id as a string
+    <method name = "peer uuid">
+        Return the sending peer's uuid as a string
         <return type = "string" />
     </method>
 
-    <method name = "name">
+    <method name = "peer name">
         Return the sending peer's public name as a string
         <return type = "string" />
     </method>
 
-    <method name = "address">
+    <method name = "peer addr">
         Return the sending peer's ipaddress as a string
         <return type = "string" />
     </method>
@@ -71,7 +71,7 @@
     </method>
 
     <method name = "msg">
-        Returns the incoming message payload (currently one frame)
+        Returns the incoming message payload
         <return type = "zmsg" />
     </method>
 
diff --git a/bindings/nodejs/binding.cc b/bindings/nodejs/binding.cc
index 53cfb6afe..9f855b6ad 100644
--- a/bindings/nodejs/binding.cc
+++ b/bindings/nodejs/binding.cc
@@ -2,6 +2,7 @@
 #include "nan.h"
 
 using namespace v8;
+using namespace Nan;
 
 class Zyre: public Nan::ObjectWrap {
     public:
@@ -15,6 +16,7 @@ class Zyre: public Nan::ObjectWrap {
 
             // Prototypes
             Nan::SetPrototypeMethod (tpl, "destroy", destroy);
+            Nan::SetPrototypeMethod (tpl, "defined", defined);
             Nan::SetPrototypeMethod (tpl, "uuid", uuid);
             Nan::SetPrototypeMethod (tpl, "name", name);
             Nan::SetPrototypeMethod (tpl, "start", start);
@@ -24,8 +26,8 @@ class Zyre: public Nan::ObjectWrap {
             Nan::SetPrototypeMethod (tpl, "join", join);
             Nan::SetPrototypeMethod (tpl, "leave", leave);
             Nan::SetPrototypeMethod (tpl, "print", print);
-            Nan::SetPrototypeMethod (tpl, "whispers", whispers);
-            Nan::SetPrototypeMethod (tpl, "shouts", shouts);
+            Nan::SetPrototypeMethod (tpl, "whisper", whisper);
+            Nan::SetPrototypeMethod (tpl, "shout", shout);
             Nan::SetPrototypeMethod (tpl, "recv", recv);
 
             constructor ().Reset (Nan::GetFunction (tpl).ToLocalChecked ());
@@ -35,61 +37,68 @@ class Zyre: public Nan::ObjectWrap {
     private:
         explicit Zyre (char *name = NULL) {
             self = zyre_new (name);
-            assert (self);
         }
         ~Zyre () {
         }
 
     static NAN_METHOD (New) {
         assert (info.IsConstructCall ());
-        Zyre *obj;
+        Zyre *zyre;
         if (info [0]->IsString ()) {
             Nan::Utf8String name (info [0].As<String>());
-            obj = new Zyre (*name);
+            zyre = new Zyre (*name);
         }
         else
-            obj = new Zyre ();
-        obj->Wrap (info.This ());
-        info.GetReturnValue ().Set (info.This ());
+            zyre = new Zyre ();
+
+        if (zyre) {
+            zyre->Wrap (info.This ());
+            info.GetReturnValue ().Set (info.This ());
+        }
     }
 
     static NAN_METHOD (destroy) {
-        Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
-        zyre_destroy (&obj->self);
+        Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+        zyre_destroy (&zyre->self);
+    }
+
+    static NAN_METHOD (defined) {
+        Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+        info.GetReturnValue ().Set (Nan::New (zyre->self != NULL));
     }
 
     static NAN_METHOD (uuid) {
-        Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
-        info.GetReturnValue ().Set (Nan::New (zyre_uuid (obj->self)).ToLocalChecked ());
+        Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+        info.GetReturnValue ().Set (Nan::New (zyre_uuid (zyre->self)).ToLocalChecked ());
     }
 
     static NAN_METHOD (name) {
-        Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
-        info.GetReturnValue ().Set (Nan::New (zyre_name (obj->self)).ToLocalChecked ());
+        Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+        info.GetReturnValue ().Set (Nan::New (zyre_name (zyre->self)).ToLocalChecked ());
     }
 
     static NAN_METHOD (start) {
-        Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
-        zyre_start (obj->self);
+        Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+        zyre_start (zyre->self);
     }
 
     static NAN_METHOD (stop) {
-        Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
-        zyre_stop (obj->self);
+        Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+        zyre_stop (zyre->self);
     }
 
     static NAN_METHOD (set_verbose) {
-        Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
-        zyre_set_verbose (obj->self);
+        Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+        zyre_set_verbose (zyre->self);
     }
 
     static NAN_METHOD (set_header) {
         if (info [0]->IsString ()
         &&  info [1]->IsString ()) {
-            Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+            Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
             Nan::Utf8String name (info [0].As<String>());
             Nan::Utf8String value (info [0].As<String>());
-            zyre_set_header (obj->self, *name, "%s", *value);
+            zyre_set_header (zyre->self, *name, "%s", *value);
         }
         else
             return Nan::ThrowTypeError (".set_header() expects name and value as strings");
@@ -97,9 +106,9 @@ class Zyre: public Nan::ObjectWrap {
 
     static NAN_METHOD (join) {
         if (info [0]->IsString ()) {
-            Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+            Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
             Nan::Utf8String group (info [0].As<String>());
-            zyre_join (obj->self, *group);
+            zyre_join (zyre->self, *group);
         }
         else
             return Nan::ThrowTypeError (".join() expects group as string");
@@ -107,41 +116,45 @@ class Zyre: public Nan::ObjectWrap {
 
     static NAN_METHOD (leave) {
         if (info [0]->IsString ()) {
-            Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+            Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
             Nan::Utf8String group (info [0].As<String>());
-            zyre_leave (obj->self, *group);
+            zyre_leave (zyre->self, *group);
         }
         else
             return Nan::ThrowTypeError (".leave() expects group as string");
     }
 
-    static NAN_METHOD (whispers) {
+    static NAN_METHOD (whisper) {
         if (info [0]->IsString ()
         &&  info [1]->IsString ()) {
-            Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+            Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
             Nan::Utf8String peer (info [0].As<String>());
-            Nan::Utf8String message (info [0].As<String>());
-            zyre_shouts (obj->self, *peer, "%s", *message);
+            Nan::Utf8String string (info [0].As<String>());
+            zmsg_t *msg = zmsg_new ();
+            zmsg_pushstr (msg, *string);
+            zyre_whisper (zyre->self, *peer, &msg);
         }
         else
-            return Nan::ThrowTypeError (".set_header() expects peer and message as strings");
+            return Nan::ThrowTypeError (".whisper() expects peer and message as strings");
     }
 
-    static NAN_METHOD (shouts) {
+    static NAN_METHOD (shout) {
         if (info [0]->IsString ()
         &&  info [1]->IsString ()) {
-            Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+            Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
             Nan::Utf8String group (info [0].As<String>());
-            Nan::Utf8String message (info [0].As<String>());
-            zyre_shouts (obj->self, *group, "%s", *message);
+            Nan::Utf8String string (info [0].As<String>());
+            zmsg_t *msg = zmsg_new ();
+            zmsg_pushstr (msg, *string);
+            zyre_shout (zyre->self, *group, &msg);
         }
         else
-            return Nan::ThrowTypeError (".set_header() expects group and message as strings");
+            return Nan::ThrowTypeError (".shout() expects group and message as strings");
     }
 
     static NAN_METHOD (recv) {
-        Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
-        zmsg_t *msg = zyre_recv (obj->self);
+        Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+        zmsg_t *msg = zyre_recv (zyre->self);
         if (msg) {
             char *string = zmsg_popstr (msg);
             info.GetReturnValue ().Set (Nan::New (string).ToLocalChecked ());
@@ -150,8 +163,8 @@ class Zyre: public Nan::ObjectWrap {
     }
 
     static NAN_METHOD (print) {
-        Zyre *obj = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
-        zyre_print (obj->self);
+        Zyre *zyre = Nan::ObjectWrap::Unwrap <Zyre> (info.Holder ());
+        zyre_print (zyre->self);
     }
 
     static Nan::Persistent <Function> & constructor () {
@@ -160,6 +173,202 @@ class Zyre: public Nan::ObjectWrap {
     }
 
     zyre_t *self;
+    public:
+        zyre_t *get_self () {
+            return self;
+        }
 };
 
-NODE_MODULE (zyre, Zyre::Init)
+class ZyreEvent: public Nan::ObjectWrap {
+    public:
+        static NAN_MODULE_INIT (Init) {
+            Nan::HandleScope scope;
+
+            // Prepare constructor template
+            Local <FunctionTemplate> tpl = Nan::New <FunctionTemplate> (New);
+            tpl->SetClassName (Nan::New ("ZyreEvent").ToLocalChecked ());
+            tpl->InstanceTemplate ()->SetInternalFieldCount (1);
+
+            // Prototypes
+            Nan::SetPrototypeMethod (tpl, "destroy", destroy);
+            Nan::SetPrototypeMethod (tpl, "defined", defined);
+            Nan::SetPrototypeMethod (tpl, "type", type);
+            Nan::SetPrototypeMethod (tpl, "type_name", type_name);
+            Nan::SetPrototypeMethod (tpl, "peer_id", peer_id);
+            Nan::SetPrototypeMethod (tpl, "peer_name", peer_name);
+            Nan::SetPrototypeMethod (tpl, "peer_addr", peer_addr);
+            Nan::SetPrototypeMethod (tpl, "header", header);
+            Nan::SetPrototypeMethod (tpl, "group", group);
+            Nan::SetPrototypeMethod (tpl, "msg", msg);
+            Nan::SetPrototypeMethod (tpl, "print", print);
+
+            constructor ().Reset (Nan::GetFunction (tpl).ToLocalChecked ());
+            Nan::Set (target, Nan::New ("ZyreEvent").ToLocalChecked (),
+            Nan::GetFunction (tpl).ToLocalChecked ());
+        }
+    private:
+        explicit ZyreEvent (Zyre *zyre) {
+            self = zyre_event_new (zyre->get_self ());
+        }
+        ~ZyreEvent () {
+        }
+
+    static NAN_METHOD (New) {
+        assert (info.IsConstructCall ());
+        if (info [0]->IsObject ()) {
+            Zyre *zyre = Nan::ObjectWrap::Unwrap<Zyre> (info [0].As<Object>());
+            ZyreEvent *zyre_event = new ZyreEvent (zyre);
+            zyre_event->Wrap (info.This ());
+            info.GetReturnValue ().Set (info.This ());
+        }
+        else
+            return Nan::ThrowTypeError ("New ZyreEvent expects Zyre argument");
+    }
+
+    static NAN_METHOD (destroy) {
+        ZyreEvent *zyre_event = Nan::ObjectWrap::Unwrap <ZyreEvent> (info.Holder ());
+        zyre_event_destroy (&zyre_event->self);
+    }
+
+    static NAN_METHOD (defined) {
+        ZyreEvent *zyre_event = Nan::ObjectWrap::Unwrap <ZyreEvent> (info.Holder ());
+        info.GetReturnValue ().Set (Nan::New (zyre_event->self != NULL));
+    }
+
+    static NAN_METHOD (type) {
+        ZyreEvent *zyre_event = Nan::ObjectWrap::Unwrap <ZyreEvent> (info.Holder ());
+        info.GetReturnValue ().Set (Nan::New (zyre_event_type (zyre_event->self)));
+    }
+
+    static NAN_METHOD (type_name) {
+        ZyreEvent *zyre_event = Nan::ObjectWrap::Unwrap <ZyreEvent> (info.Holder ());
+        int type = zyre_event_type (zyre_event->self);
+        const char *type_name = "";
+        switch (type) {
+            case 1: type_name = "ENTER"; break;
+            case 2: type_name = "JOIN"; break;
+            case 3: type_name = "LEAVE"; break;
+            case 4: type_name = "EXIT"; break;
+            case 5: type_name = "WHISPER"; break;
+            case 6: type_name = "SHOUT"; break;
+            case 7: type_name = "STOP"; break;
+            case 8: type_name = "EVASIVE"; break;
+        }
+        info.GetReturnValue ().Set (Nan::New (type_name).ToLocalChecked ());
+    }
+
+    static NAN_METHOD (peer_id) {
+        ZyreEvent *zyre_event = Nan::ObjectWrap::Unwrap <ZyreEvent> (info.Holder ());
+        info.GetReturnValue ().Set (Nan::New (zyre_event_peer_id (zyre_event->self)).ToLocalChecked ());
+    }
+
+    static NAN_METHOD (peer_name) {
+        ZyreEvent *zyre_event = Nan::ObjectWrap::Unwrap <ZyreEvent> (info.Holder ());
+        info.GetReturnValue ().Set (Nan::New (zyre_event_peer_name (zyre_event->self)).ToLocalChecked ());
+    }
+
+    static NAN_METHOD (peer_addr) {
+        ZyreEvent *zyre_event = Nan::ObjectWrap::Unwrap <ZyreEvent> (info.Holder ());
+        info.GetReturnValue ().Set (Nan::New (zyre_event_peer_addr (zyre_event->self)).ToLocalChecked ());
+    }
+
+    static NAN_METHOD (header) {
+        if (info [0]->IsString ()) {
+            ZyreEvent *zyre_event = Nan::ObjectWrap::Unwrap <ZyreEvent> (info.Holder ());
+            Nan::Utf8String name (info [0].As<String>());
+            info.GetReturnValue ().Set (Nan::New (zyre_event_header (zyre_event->self, *name)).ToLocalChecked ());
+        }
+        else
+            return Nan::ThrowTypeError (".header() expects name as string");
+    }
+
+    static NAN_METHOD (group) {
+        ZyreEvent *zyre_event = Nan::ObjectWrap::Unwrap <ZyreEvent> (info.Holder ());
+        info.GetReturnValue ().Set (Nan::New (zyre_event_group (zyre_event->self)).ToLocalChecked ());
+    }
+
+    static NAN_METHOD (msg) {
+        ZyreEvent *zyre_event = Nan::ObjectWrap::Unwrap <ZyreEvent> (info.Holder ());
+        info.GetReturnValue ().Set (Nan::New (zyre_event_group (zyre_event->self)).ToLocalChecked ());
+        zmsg_t *msg = zmsg_dup (zyre_event_msg (zyre_event->self));
+        if (msg) {
+            char *string = zmsg_popstr (msg);
+            info.GetReturnValue ().Set (Nan::New (string).ToLocalChecked ());
+            free (string);
+            zmsg_destroy (&msg);
+        }
+    }
+
+    static NAN_METHOD (print) {
+        ZyreEvent *zyre_event = Nan::ObjectWrap::Unwrap <ZyreEvent> (info.Holder ());
+        zyre_event_print (zyre_event->self);
+    }
+
+    static Nan::Persistent <Function> & constructor () {
+        static Nan::Persistent <Function> my_constructor;
+        return my_constructor;
+    }
+
+    zyre_event_t *self;
+    public:
+        zyre_event_t *get_self () {
+            return self;
+        }
+};
+
+
+// <class name = "zyre event">
+//     <!--
+//     Copyright (c) the Contributors as noted in the AUTHORS file.
+//
+//     This file is part of Zyre, an open-source framework for proximity-based
+//     peer-to-peer applications -- See http://zyre.org.
+//
+//     This Source Code Form is subject to the terms of the Mozilla Public
+//     License, v. 2.0. If a copy of the MPL was not distributed with this
+//     file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//     -->
+//     Parsing Zyre messages
+//
+//     <enum name = "type">
+//         <constant name = "enter" value = "1" />
+//         <constant name = "join" value = "2" />
+//         <constant name = "leave" value = "3" />
+//         <constant name = "exit" value = "4" />
+//         <constant name = "whisper" value = "5" />
+//         <constant name = "shout" value = "6" />
+//         <constant name = "stop" value = "7" />
+//         <constant name = "evasive" value = "8" />
+//     </enum>
+//
+//     <method name = "header">
+//         Returns value of a header from the message headers
+//         obtained by ENTER. Return NULL if no value was found.
+//         <argument name = "name" type = "string" />
+//         <return type = "string" />
+//     </method>
+//
+//     <method name = "group">
+//         Returns the group name that a SHOUT event was sent to
+//         <return type = "string" />
+//     </method>
+//
+//     <method name = "msg">
+//         Returns the incoming message payload (currently one frame)
+//         <return type = "zmsg" />
+//     </method>
+//
+//     <method name = "print">
+//         Print event to zsys log
+//     </method>
+// </class>
+
+
+extern "C" NAN_MODULE_INIT (zyre_initialize)
+{
+    Zyre::Init (target);
+    ZyreEvent::Init (target);
+}
+
+
+NODE_MODULE (zyre, zyre_initialize)
diff --git a/bindings/nodejs/build.sh b/bindings/nodejs/build.sh
index f0fc241c0..39f4e908a 100755
--- a/bindings/nodejs/build.sh
+++ b/bindings/nodejs/build.sh
@@ -122,7 +122,7 @@ echo "I: resolving dependencies for Zyre:"
 echo "I: building Node.js binding:"
 cd $BUILD_ROOT
 test ! -d node_modules/nan && npm install nan@latest --save
-test ! -d node_modules/bindings && npm install bindings --save
+test ! -d node_modules/bindings && npm install bindings --save-dev
 
 #   Still not sure of this
 if [ $ELECTRON -eq 1 ]; then
diff --git a/bindings/nodejs/package.json b/bindings/nodejs/package.json
index c2927f6b7..b8bd11266 100644
--- a/bindings/nodejs/package.json
+++ b/bindings/nodejs/package.json
@@ -15,8 +15,6 @@
     "url": "git://github.com/zeromq/zyre.git"
   },
   "dependencies": {
-    "bindings": "^1.2.1",
     "nan": "^2.2.0",
-    "sleep": "^3.0.1"
   }
 }
diff --git a/bindings/nodejs/test.js b/bindings/nodejs/test.js
deleted file mode 100644
index 4872cb8e8..000000000
--- a/bindings/nodejs/test.js
+++ /dev/null
@@ -1,17 +0,0 @@
-//  Minimal sanity test
-
-var ZyreBinding = require ('bindings')('zyre');
-var zyre = new ZyreBinding.Zyre ("World");
-zyre.setVerbose ();
-zyre.start ();
-zyre.join ("GLOBAL");
-
-console.log ('Hello: ' + zyre.name ());
-console.log ('Waiting for 2 seconds, then exiting');
-
-var sleep = require ('sleep');
-sleep.sleep (2);
-
-zyre.print ();
-zyre.stop ();
-zyre.destroy ();
diff --git a/bindings/nodejs/zpinger.js b/bindings/nodejs/zpinger.js
new file mode 100644
index 000000000..f877bca44
--- /dev/null
+++ b/bindings/nodejs/zpinger.js
@@ -0,0 +1,106 @@
+/*  =========================================================================
+    zpinger.js - ping other peers in a ZRE network
+
+    -------------------------------------------------------------------------
+    Copyright (c) the Contributors as noted in the AUTHORS file.
+
+    This file is part of Zyre, an open-source framework for proximity-based
+    peer-to-peer applications -- See http://zyre.org.
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+    =========================================================================
+*/
+
+/*
+@header
+zpinger tells you what other Zyre nodes are running. Use this to debug
+network issues. Run with -v option to get more detail on Zyre's internal
+flow for each event.
+@discuss
+Note that this will detect and speak to Zyre nodes on the entire local
+network.
+@end
+*/
+
+//  Implementation of zpinger in Node.js
+//  When you run this, it shows activity on the Zyre network
+
+Date.prototype.DateTime = function () {
+    return (
+        +  (this.getYear () - 100) + "-"
+        + ((this.getMonth () + 1 < 10)? "0" :"") + (this.getMonth () + 1) + "-"
+        + ((this.getDate () < 10)? "0" :"") + this.getDate () + " "
+        + ((this.getHours () < 10)? "0": "") + this.getHours () + ":"
+        + ((this.getMinutes () < 10)? "0": "") + this.getMinutes () + ":"
+        + ((this.getSeconds () < 10)? "0": "") + this.getSeconds ()
+    );
+}
+
+//  Print informational message prefixed by date/time
+function info (string)
+{
+    var date = new Date ();
+    console.log ("I: " + date.DateTime () + " " + string);
+}
+
+var verbose = false;
+
+process.argv.forEach (function (value, index, array) {
+    if (value == "-h" || value == "--help") {
+        console.log ("zpinger.js [options] ...");
+        console.log ("  --verbose / -v         verbose test output");
+        console.log ("  --help / -h            this help");
+        process.exit ();
+    }
+    else
+    if (value == "-v" || value == "--verbose") {
+        verbose = true;
+        console.log (process.versions);
+    }
+});
+
+var ZyreBinding = require ('bindings')('zyre');
+var zyre = new ZyreBinding.Zyre ();
+info ("Create Zyre node, uuid=" + zyre.uuid () + " name=" + zyre.name ());
+
+if (verbose) {
+    zyre.setVerbose ();
+}
+zyre.start ();
+zyre.join ("GLOBAL");
+if (verbose) {
+    zyre.print ();
+}
+
+while (true) {
+    var event = new ZyreBinding.ZyreEvent (zyre);
+    if (!event.defined ())
+        break;              //  Interrupted
+    if (verbose) {
+        event.print ();
+    }
+    if (event.type_name () == "ENTER") {
+        //  If new peer, say hello to it and wait for it to answer us
+        info ("[" + event.peer_name () + "] peer entered");
+        zyre.whisper (event.peer_id (), "Hello");
+    }
+    else
+    if (event.type_name () == "EXIT") {
+        info ("[" + event.peer_name () + "] peer exited");
+    }
+    else
+    if (event.type_name () == "WHISPER") {
+        info ("[" + event.peer_name () + "] received ping (WHISPER)");
+        zyre.shout ("GLOBAL", "Hello");
+    }
+    else
+    if (event.type_name () == "SHOUT") {
+        info ("[" + event.peer_name () + "]("
+                  + event.group () + ") received ping (SHOUT)");
+    }
+    event.destroy ();
+}
+zyre.stop ();
+zyre.destroy ();
diff --git a/include/zyre.h b/include/zyre.h
index e73fa35fe..972263e96 100644
--- a/include/zyre.h
+++ b/include/zyre.h
@@ -57,7 +57,7 @@ ZYRE_EXPORT const char *
 //  Set node header; these are provided to other nodes during discovery
 //  and come in each ENTER message.                                    
 ZYRE_EXPORT void
-    zyre_set_header (zyre_t *self, const char *name, const char *format, ...) CHECK_PRINTF (3);
+    zyre_set_header (zyre_t *self, const char *name, const char *format, ...);
 
 //  *** Draft method, for development use, may change without warning ***
 //  Set verbose mode; this tells the node to log all traffic as well as 
@@ -95,7 +95,7 @@ ZYRE_EXPORT void
 //  that is meaningful to remote as well as local nodes). Returns 0 if       
 //  the bind was successful, else -1.                                        
 ZYRE_EXPORT int
-    zyre_set_endpoint (zyre_t *self, const char *format, ...) CHECK_PRINTF (2);
+    zyre_set_endpoint (zyre_t *self, const char *format, ...);
 
 //  *** Draft method, for development use, may change without warning ***
 //  Set-up gossip discovery of other nodes. At least one node in the cluster
@@ -103,14 +103,14 @@ ZYRE_EXPORT int
 //  it. Note that gossip endpoints are completely distinct from Zyre node   
 //  endpoints, and should not overlap (they can use the same transport).    
 ZYRE_EXPORT void
-    zyre_gossip_bind (zyre_t *self, const char *format, ...) CHECK_PRINTF (2);
+    zyre_gossip_bind (zyre_t *self, const char *format, ...);
 
 //  *** Draft method, for development use, may change without warning ***
 //  Set-up gossip discovery of other nodes. A node may connect to multiple
 //  other nodes, for redundancy paths. For details of the gossip network  
 //  design, see the CZMQ zgossip class.                                   
 ZYRE_EXPORT void
-    zyre_gossip_connect (zyre_t *self, const char *format, ...) CHECK_PRINTF (2);
+    zyre_gossip_connect (zyre_t *self, const char *format, ...);
 
 //  *** Draft method, for development use, may change without warning ***
 //  Start node, after setting header values. When you start a node it
@@ -159,12 +159,12 @@ ZYRE_EXPORT int
 //  *** Draft method, for development use, may change without warning ***
 //  Send formatted string to a single peer specified as UUID string
 ZYRE_EXPORT int
-    zyre_whispers (zyre_t *self, const char *peer, const char *format, ...) CHECK_PRINTF (3);
+    zyre_whispers (zyre_t *self, const char *peer, const char *format, ...);
 
 //  *** Draft method, for development use, may change without warning ***
 //  Send formatted string to a named group
 ZYRE_EXPORT int
-    zyre_shouts (zyre_t *self, const char *group, const char *format, ...) CHECK_PRINTF (3);
+    zyre_shouts (zyre_t *self, const char *group, const char *format, ...);
 
 //  *** Draft method, for development use, may change without warning ***
 //  Return zlist of current peer ids.
@@ -218,13 +218,21 @@ ZYRE_EXPORT void
     zyre_test (bool verbose);
 
 #endif // ZYRE_BUILD_DRAFT_API
+//  @ignore
+void
+    zyre_set_header (zyre_t *self, const char *name, const char *format, ...) CHECK_PRINTF (3);
+int
+    zyre_set_endpoint (zyre_t *self, const char *format, ...) CHECK_PRINTF (2);
+void
+    zyre_gossip_bind (zyre_t *self, const char *format, ...) CHECK_PRINTF (2);
+void
+    zyre_gossip_connect (zyre_t *self, const char *format, ...) CHECK_PRINTF (2);
+int
+    zyre_whispers (zyre_t *self, const char *peer, const char *format, ...) CHECK_PRINTF (3);
+int
+    zyre_shouts (zyre_t *self, const char *group, const char *format, ...) CHECK_PRINTF (3);
 //  @end
 
-
-
-
-
-
 #define zyre_dump(z) zyre_print((z))
 
 #ifdef __cplusplus
diff --git a/include/zyre_event.h b/include/zyre_event.h
index 5a4005aa9..98d996e70 100644
--- a/include/zyre_event.h
+++ b/include/zyre_event.h
@@ -57,19 +57,19 @@ ZYRE_EXPORT zyre_event_type_t
     zyre_event_type (zyre_event_t *self);
 
 //  *** Draft method, for development use, may change without warning ***
-//  Return the sending peer's id as a string
+//  Return the sending peer's uuid as a string
 ZYRE_EXPORT const char *
-    zyre_event_sender (zyre_event_t *self);
+    zyre_event_peer_uuid (zyre_event_t *self);
 
 //  *** Draft method, for development use, may change without warning ***
 //  Return the sending peer's public name as a string
 ZYRE_EXPORT const char *
-    zyre_event_name (zyre_event_t *self);
+    zyre_event_peer_name (zyre_event_t *self);
 
 //  *** Draft method, for development use, may change without warning ***
 //  Return the sending peer's ipaddress as a string
 ZYRE_EXPORT const char *
-    zyre_event_address (zyre_event_t *self);
+    zyre_event_peer_addr (zyre_event_t *self);
 
 //  *** Draft method, for development use, may change without warning ***
 //  Returns the event headers, or NULL if there are none
@@ -88,7 +88,7 @@ ZYRE_EXPORT const char *
     zyre_event_group (zyre_event_t *self);
 
 //  *** Draft method, for development use, may change without warning ***
-//  Returns the incoming message payload (currently one frame)
+//  Returns the incoming message payload
 ZYRE_EXPORT zmsg_t *
     zyre_event_msg (zyre_event_t *self);
 
@@ -105,14 +105,6 @@ ZYRE_EXPORT void
 #endif // ZYRE_BUILD_DRAFT_API
 //  @end
 
-
-
-
-
-
-
-
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/zpinger.c b/src/zpinger.c
index 86032bb42..39fe5ca9f 100644
--- a/src/zpinger.c
+++ b/src/zpinger.c
@@ -15,9 +15,12 @@
 
 /*
 @header
-    zpinger tells you what other nodes are running. Use this to debug network
-    issues.
+zpinger tells you what other Zyre nodes are running. Use this to debug
+network issues. Run with -v option to get more detail on Zyre's internal
+flow for each event.
 @discuss
+Note that this will detect and speak to Zyre nodes on the entire local
+network.
 @end
 */
 
@@ -26,43 +29,61 @@
 
 int main (int argc, char *argv [])
 {
-    zyre_t *node = zyre_new (NULL);
-    zyre_start (node);
-    zyre_join (node, "GLOBAL");
+    bool verbose = false;
+    int argn;
+    for (argn = 1; argn < argc; argn++) {
+        if (streq (argv [argn], "--help")
+        ||  streq (argv [argn], "-h")) {
+            puts ("zpinger [options] ...");
+            puts ("  --verbose / -v         verbose test output");
+            puts ("  --help / -h            this help");
+            return 0;
+        }
+        if (streq (argv [argn], "--verbose")
+        ||  streq (argv [argn], "-v"))
+            verbose = true;
+        else {
+            printf ("Unknown option: %s\n", argv [argn]);
+            return 1;
+        }
+    }
+    zyre_t *zyre = zyre_new (NULL);
+    zsys_info ("Create Zyre node, uuid=%s, name=%s", zyre_uuid (zyre), zyre_name (zyre));
+    if (verbose)
+        zyre_set_verbose (zyre);
+    zyre_start (zyre);
+    zyre_join (zyre, "GLOBAL");
+    if (verbose)
+        zyre_print (zyre);
 
     while (true) {
-        zmsg_t *incoming = zyre_recv (node);
-        if (!incoming)
+        zyre_event_t *event = zyre_event_new (zyre);
+        if (!event)
             break;              //  Interrupted
+        if (verbose)
+            zyre_event_print (event);
 
-        //  If new peer, say hello to it and wait for it to answer us
-        char *event = zmsg_popstr (incoming);
-        char *peer = zmsg_popstr (incoming);
-        char *name = zmsg_popstr (incoming);
-        if (streq (event, "ENTER")) {
-            printf ("I: [%s] peer entered\n", name);
-            zyre_whispers (node, peer, "Hello");
+        if (zyre_event_type (event) == ZYRE_EVENT_ENTER) {
+            //  If new peer, say hello to it and wait for it to answer us
+            zsys_info ("[%s] peer entered", zyre_event_peer_name (event));
+            zyre_whispers (zyre, zyre_event_peer_uuid (event), "Hello");
         }
         else
-        if (streq (event, "EXIT")) {
-            printf ("I: [%s] peer exited\n", name);
+        if (zyre_event_type (event) == ZYRE_EVENT_EXIT) {
+            zsys_info ("[%s] peer exited", zyre_event_peer_name (event));
         }
         else
-        if (streq (event, "WHISPER")) {
-            printf ("I: [%s] received ping (WHISPER)\n", name);
-            zyre_shouts (node, "GLOBAL", "Hello");
+        if (zyre_event_type (event) == ZYRE_EVENT_WHISPER) {
+            zsys_info ("[%s] received ping (WHISPER)", zyre_event_peer_name (event));
+            zyre_shouts (zyre, "GLOBAL", "Hello");
         }
         else
-        if (streq (event, "SHOUT")) {
-            char *group = zmsg_popstr (incoming);
-            printf ("I: [%s](%s) received ping (SHOUT)\n", name, group);
-            free (group);
+        if (zyre_event_type (event) == ZYRE_EVENT_SHOUT) {
+            zsys_info ("[%s](%s) received ping (SHOUT)",
+                       zyre_event_peer_name (event), zyre_event_group (event));
         }
-        free (event);
-        free (peer);
-        free (name);
-        zmsg_destroy (&incoming);
+        zyre_event_destroy (&event);
     }
-    zyre_destroy (&node);
+    zyre_destroy (&zyre);
     return 0;
 }
diff --git a/src/zyre_event.c b/src/zyre_event.c
index 193f37a68..51722f2d0 100644
--- a/src/zyre_event.c
+++ b/src/zyre_event.c
@@ -29,9 +29,9 @@
 
 struct _zyre_event_t {
     zyre_event_type_t type; //  Event type
-    char *sender;           //  Sender UUID as string
-    char *name;             //  Sender public name as string
-    char *address;          //  Sender ipaddress as string, for an ENTER event
+    char *peer_uuid;        //  Sender UUID as string
+    char *peer_name;        //  Sender public name as string
+    char *peer_addr;        //  Sender ipaddress as string, for an ENTER event
     zhash_t *headers;       //  Headers, for an ENTER event
     char *group;            //  Group name for a SHOUT event
     zmsg_t *msg;            //  Message payload for SHOUT or WHISPER
@@ -54,8 +54,8 @@ zyre_event_new (zyre_t *node)
     assert (self);
 
     char *type = zmsg_popstr (msg);
-    self->sender = zmsg_popstr (msg);
-    self->name = zmsg_popstr (msg);
+    self->peer_uuid = zmsg_popstr (msg);
+    self->peer_name = zmsg_popstr (msg);
 
     if (streq (type, "ENTER")) {
         self->type = ZYRE_EVENT_ENTER;
@@ -64,7 +64,7 @@ zyre_event_new (zyre_t *node)
             self->headers = zhash_unpack (headers);
             zframe_destroy (&headers);
         }
-        self->address = zmsg_popstr (msg);
+        self->peer_addr = zmsg_popstr (msg);
     }
     else
     if (streq (type, "EXIT"))
@@ -120,10 +120,10 @@ zyre_event_destroy (zyre_event_t **self_p)
         zyre_event_t *self = *self_p;
         zhash_destroy (&self->headers);
         zmsg_destroy (&self->msg);
-        free (self->sender);
-        free (self->address);
+        free (self->peer_uuid);
+        free (self->peer_name);
+        free (self->peer_addr);
         free (self->group);
-        free (self->name);
         free (self);
         *self_p = NULL;
     }
@@ -143,14 +143,15 @@ void
 zyre_event_print (zyre_event_t *self)
 {
     zsys_info ("zyre_event:");
-    zsys_info (" - from name=%s uuid=%s", zyre_event_name(self), zyre_event_sender(self));
+    zsys_info (" - from name=%s uuid=%s",
+               zyre_event_peer_name (self), zyre_event_peer_uuid (self));
 
     switch (self->type) {
         case ZYRE_EVENT_ENTER:
             zsys_info (" - type=ENTER");
             zsys_info (" - headers=%zu:", zhash_size (self->headers));
             zhash_foreach (self->headers, (zhash_foreach_fn *) zyre_event_log_pair, self);
-            zsys_info (" - address=%s", zyre_event_address(self));
+            zsys_info (" - address=%s", zyre_event_peer_addr (self));
             break;
 
         case ZYRE_EVENT_EXIT:
@@ -203,13 +204,13 @@ zyre_event_type (zyre_event_t *self)
 
 
 //  --------------------------------------------------------------------------
-//  Return the sending peer's id as a string
+//  Return the sending peer's UUID as a string
 
 const char *
-zyre_event_sender (zyre_event_t *self)
+zyre_event_peer_uuid (zyre_event_t *self)
 {
     assert (self);
-    return self->sender;
+    return self->peer_uuid;
 }
 
 
@@ -217,10 +218,10 @@ zyre_event_sender (zyre_event_t *self)
 //  Return the sending peer's public name as a string
 
 const char *
-zyre_event_name (zyre_event_t *self)
+zyre_event_peer_name (zyre_event_t *self)
 {
     assert (self);
-    return self->name;
+    return self->peer_name;
 }
 
 
@@ -228,10 +229,10 @@ zyre_event_name (zyre_event_t *self)
 //  Return the sending peer's ipaddress as a string
 
 const char *
-zyre_event_address (zyre_event_t *self)
+zyre_event_peer_addr (zyre_event_t *self)
 {
     assert (self);
-    return self->address;
+    return self->peer_addr;
 }
 
 
@@ -324,12 +325,12 @@ zyre_event_test (bool verbose)
     //  Parse ENTER
     zyre_event_t *event = zyre_event_new (node2);
     assert (zyre_event_type (event) == ZYRE_EVENT_ENTER);
-    const char *sender = zyre_event_sender (event);
+    const char *sender = zyre_event_peer_uuid (event);
     assert (sender);
-    const char *name = zyre_event_name (event);
+    const char *name = zyre_event_peer_name (event);
     assert (name);
     assert (streq (name, "node1"));
-    const char *address = zyre_event_address (event);
+    const char *address = zyre_event_peer_addr (event);
     assert (address);
     const char *header = zyre_event_header (event, "X-HELLO");
     assert (header);