+Delicious data with mmstats
+ * What is my app doing?
+ * How do you inspect for that state?
+ * Simple in-memory stats get hard to expose in multi-process environments.
+ * Universally supported
+ * Operational burden (rotating, shipping, routing, etc)
+ * Records events more than inspects state
+ * Difficult to predict where needed
+ * Performance impact if too verbose
+ * Fast, sexy, "enterprise"
+ * Do you want a graph or a graph?
+ * Have fun installing it.
+ * Still not great for introspection.
+ Solution #3: socketconsole
+ * Very useful for deadlocks, blocking code, threaded app.
+ * Simple to integrate::
+ * Doesn't work with gevent or eventlet monkeypatching.
+ * Doesn't work with greenthreads.
+ * Limited functionality.
+ * All the fun of Python threads.
+ Solution #4: REPL Backdoors
+ * Changing code at runtime is for winners.
+ * Inspect all the things!
+ * With great power comes great responsibility.
+ * Requires threads or event loop.
+ * Still can't reach all state.
+ * Well, you wanted introspection.
+ * Has some Python helpers: ``pygdb``, ``gdb-heap``
+ * Seriously? Definitily only a a last resort.
+ * Universally supported.
+ * Powerful, extensible, 2-way.
+ * Where "universal" means "runs on the JVM".
+ * Not as easy to monitor as you'd think.
+ .. note:: Python needs this.
+ * Simple API to expose state.
+ * Separate publishing from reading, aggregating, etc.
+ * Language, platform, framework agnostic.
+ * Minimal & predictable performance impact.
+ * Optional persistence (e.g. post-mortems)
+ * ``mmap`` alows sharing memory between processes.
+ * Language independent data structure:
+ * Series of fields (structs)
+ * Fields have ``label``, ``type``, and ``values``.
+ * Exposed in Python app as a model class.
+ Performance Implementation
+ Single writer, multi-reader
+ * No syscalls (write, read, send, recv, etc).
+ * All in userspace for readers & writers.
+ * Reading has no impact on writers.
+ Consistency without Locks
+ Q: How are reads consistent without locks?