DjangoCon 2011 Notes / docs / pdx_python_meetup_sept_11.rst

Kenneth Love e528121 

Kenneth Love 23264ab 
Kenneth Love e528121 

Kenneth Love 23264ab 

Kenneth Love e528121 
Kenneth Love 23264ab 

Kenneth Love 44bebcd 
Kenneth Love 23264ab 

PDX Python Meetup

September, 2011

Delicious data with mmstats


        * You have an app.
        * It has state.
        * What is my app doing?
        * How do you inspect for that state?
        * Simple in-memory stats get hard to expose in multi-process environments.

    Solution #1: Logging


            * Universally supported
            * Easily enhanced
            * Persistent


            * Libraries suck
            * Operational burden (rotating, shipping, routing, etc)
            * Records events more than inspects state
            * Difficult to predict where needed
            * Performance impact if too verbose

    Solution #2: Graphite


            * Fast, sexy, "enterprise"
            * Python


            * Do you want a graph or a graph?
            * Have fun installing it.
            * Still not great for introspection.

    Solution #3: socketconsole


            * Pure Python.
            * Very useful for deadlocks, blocking code, threaded app.
            * Simple to integrate::

                import socketconsole


            * CPython only.
            * 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


            * Pure Python!
            * 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.

    Solution #5: GDB


            * Well, you wanted introspection.
            * Has some Python helpers: ``pygdb``, ``gdb-heap``


            * Seriously? Definitily only a a last resort.

    Solution #6: JMX


            * Universally supported.
            * Powerful, extensible, 2-way.
            * Helpful tools.


            * Where "universal" means "runs on the JVM".
            * Not as easy to monitor as you'd think.

    .. note:: Python needs this.

    ``mmstats`` Goals

        * 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)
        * 1-way (for now?)

    What is ``mmstats``?

        * ``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 locks.
        * No syscalls (write, read, send, recv, etc).
        * All in userspace for readers & writers.
        * Reading has no impact on writers.
        * Fixed field sizes.

    Consistency without Locks

        Q: How are reads consistent without locks?
            A: Double buffering.