gistfile1.py

from time import time
import socket
import struct
import pickle


class GraphiteClient:

    def __init__(self,
                 graphite_host='localhost',
                 pickle_port=2004,
                 batch_size=255,
                 failed_metric_window=20,
                 publish_timeout=10):
        self.graphite_host = graphite_host
        self.pickle_port = pickle_port
        self.metric_window_size = failed_metric_window
        self.stored_metrics = []
        self.failed_metrics = []
        self.socket = socket.socket()
        self.socket.settimeout(publish_timeout)

    def build_metric_pickle(self):
        data = pickle.dumps(self.stored_metrics)
        return struct.pack("!L", len(data)) + data

    def publish(self):
        pickled_metrics = self.build_metric_pickle()
        try:
            self.socket.connect((self.graphite_host, self.pickle_port))
            self.socket.send(pickled_metrics)
            while self.failed_metrics:
                pickled_metrics = self.failed_metrics.pop()
                self.socket.send(pickled_metrics)
        except socket.timeout:
            if self.metric_window_size <= len(self.failed_metrics):
                self.failed_metrics.pop(0)
            self.failed_metrics.append(pickled_metrics)
        finally:
            self.stored_metrics = []
            self.socket.close()

    def add_metric(self, path, value):
        self.stored_metrics.append(
            (path, (time(), value))
        )
        if len(self.stored_metrics) is self.batch_size:
            self.publish()


def metric_wrapper(f, *args, **kwargs):
    locals()[kwargs.get('collector_name', 'collector')] = GraphiteClient()
    ret = f(*args, **kwargs)
    locals()[kwargs.get('collector_name', 'collector')].publish()