Metadata-Version: 1.0
Name: graphite-pymetrics
Version: 0.1.1
Summary: A simple Python metrics framework to use with carbon/graphite.
Home-page: http://www.esn.me
Author: Ronnie Kolehmainen
Author-email: ronnie@esn.me
License: MIT
Download-URL: http://github.com/esnme/graphite-pymetrics
Description: graphite-pymetrics
        ==================
        graphite-pymetrics is a lightweight Python framework which makes it super simple to add application metrics
        that is sent to a remote graphite/carbon server.
        
        All that is needed is this package (which also includes pystatsd) and access to a remote graphite server.
        
        To install it just run Pip as usual::
        
        $ pip install graphite-pymetrics
        
        Package requirements:
        - pystatsd==0.1.6
        - gevent
        
        =====
        Usage
        =====
        Make sure there is a local graphite proxy running - start it at an early point in your application::
        
        from metrics.graphite import start_graphite_proxy
        start_graphite_proxy({"host": "graphite.mycompany.com", "port": 2003})
        
        The proxy is pystatsd, a local server that receives UDP packets from the metrics client and periodically
        emits data to graphite over TCP.
        
        ~~~~~~~~
        Counters
        ~~~~~~~~
        To add a counter for anything anywhere in your code, use Metric.add::
        
        from metrics import Metric
        
        Metric.add("foo.bar")
        
        Use the @metric decorator to count specific method invocations::
        
        from metrics import metric
        
        @metric("bar.baz")
        def foo():
        # do stuff here
        
        ~~~~~~
        Timing
        ~~~~~~
        There are several ways to log timing. The most naive way is to first measure time manually and then submit it::
        
        from metrics import Metric
        import time
        
        start = time.time()
        # do stuff
        elapsed = time.time() - start
        Metric.timing("do.stuff", elapsed)
        
        
        An easier way is to to let the metric client keep track of time with Metric.start_timing and call done() on the
        returned timing instance. Following is an example for measuring time consumed for every endpoint individually
        in a Flask webapp::
        
        from metrics import Metric
        from flask import Blueprint, current_app, request, g
        
        app = Blueprint("myapp", __name__)
        
        @app.before_request
        def before_request():
        try:
        g.timing = Metric.start_timing(str(request.endpoint))  # start timing
        except:
        current_app.logger.error("Unable to time call for 'request.endpoint'")
        
        @app.teardown_request
        def teardown_request(exc):
        try:
        g.timing.done()                                        # stop timing
        except:
        current_app.logger.error("Timing not available")
        
        
        Similar to the @metric decorator there is a @timing decorator which is used to measure time for specific methods::
        
        from metrics import timing
        
        @timing("heavy.task")
        def heavy_task(x, y, z):
        # do heavy stuff here
        
        
Platform: any
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Development Status :: 4 - Beta
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Intended Audience :: Developers
