Add a Graphtie Bridge.

brian-brazil · brian-brazil · commit ae44fe0ac527 · 2015-06-21T16:26:11.000+01:00
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,5 @@
+build
+dist
+*.egg-info
+*.pyc
+*.swp
diff --git a/README.md b/README.md
@@ -208,7 +208,7 @@ ProcessCollector(namespace='mydaemon', pid=lambda: open('/var/run/daemon.pid').r
 
 There are several options for exporting metrics.
 
-## HTTP
+### HTTP
 
 Metrics are usually exposed over HTTP, to be read by the Prometheus server.
 
@@ -226,7 +226,7 @@ To add Prometheus exposition to an existing HTTP server, see the `MetricsServlet
 which provides a `BaseHTTPRequestHandler`. It also serves as a simple example of how
 to write a custom endpoint.
 
-## Node exporter textfile collector
+### Node exporter textfile collector
 
 The [textfile collector](https://github.com/prometheus/node_exporter#textfile-collector)
 allows machine-level statistics to be exported out via the Node exporter.
@@ -245,3 +245,22 @@ write_to_textfile('/configured/textfile/path/raid.prom', registry)
 
 A separate registry is used, as the default registry may contain other metrics
 such as those from the Process Collector.
+
+## Bridges
+
+It is also possible to expose metrics to systems other than Prometheus.
+This allows you to take advantage of Prometheus instrumentation even
+if you are not quite ready to fully transition to Prometheus yet.
+
+### Graphite
+
+Metrics are pushed over TCP in the Graphite plaintext format.
+
+```python
+from prometheus_client.bridge.graphite import GraphiteBridge
+gb = GraphiteBridge(('graphite.your.org', 2003))
+# Push once.
+gb.push()
+# Push every 10 seconds in a daemon thread.
+gb.start(10.0)
+```
diff --git a/prometheus_client/bridge/__init__.py b/prometheus_client/bridge/__init__.py
diff --git a/prometheus_client/bridge/graphite.py b/prometheus_client/bridge/graphite.py
@@ -0,0 +1,72 @@
+#!/usr/bin/python
+from __future__ import unicode_literals
+
+import re
+import socket
+import time
+import threading
+
+from .. import core
+
+# Roughly, have to keep to what works as a file name.
+# We also remove periods, so labels can be distinguished.
+_INVALID_GRAPHITE_CHARS = re.compile(r"[^a-zA-Z0-9_-]")
+
+def _sanitize(s):
+  return _INVALID_GRAPHITE_CHARS.sub('_', s)
+  
+
+class _RegularPush(threading.Thread):
+
+    def __init__(self, pusher, interval):
+        super(_RegularPush, self).__init__()
+        self._pusher = pusher
+        self._interval = interval
+
+    def run(self):
+        wait_until = time.time()
+        while True:
+            while True:
+                now = time.time()
+                if now >= wait_until:
+                   # May need to skip some pushes.
+                   while wait_until < now:
+                       wait_until += self._interval
+                   break
+                # time.sleep can return early.
+                time.sleep(wait_until - now)
+            self._pusher.push()
+
+
+class GraphiteBridge(object):
+    def __init__(self, address, registry=core.REGISTRY, timeout_seconds=30, _time=time):
+        self._address = address
+        self._registry = registry
+        self._timeout = timeout_seconds
+        self._time = _time
+
+    def push(self):
+          now = int(self._time.time())
+          output = []
+          for metric in self._registry.collect():
+              for name, labels, value in metric._samples:
+                  if labels:
+                      labelstr = '.' + '.'.join(
+                          ['{0}.{1}'.format(
+                               _sanitize(k), _sanitize(v))
+                               for k, v in sorted(labels.items())])
+                  else:
+                      labelstr = ''
+                  output.append('{0}{1} {2} {3}\n'.format(
+                      _sanitize(name), labelstr, float(value), now))
+
+          conn = socket.create_connection(self._address, self._timeout)
+          conn.sendall(''.join(output).encode('ascii'))
+          conn.close()
+
+    def start(self, interval=60.0):
+        t = _RegularPush(self, interval)
+        t.daemon = True
+        t.start()
+        
+
diff --git a/tests/graphite_bridge.py b/tests/graphite_bridge.py
@@ -0,0 +1,58 @@
+import unittest
+import threading
+try:
+    import SocketServer
+except ImportError:
+    import socketserver as SocketServer
+
+from prometheus_client import Counter, CollectorRegistry
+from prometheus_client.bridge.graphite import GraphiteBridge
+
+class FakeTime(object):
+    def time(self):
+        return 1434898897.5
+
+class TestGraphiteBridge(unittest.TestCase):
+    def setUp(self):
+        self.registry = CollectorRegistry()
+
+        self.data = ''
+        class TCPHandler(SocketServer.BaseRequestHandler):
+            def handle(s):
+                self.data = s.request.recv(1024)
+        server = SocketServer.TCPServer(('', 0), TCPHandler)
+        class ServingThread(threading.Thread):
+            def run(self):
+                server.handle_request()
+                server.socket.close()
+        self.t = ServingThread()
+        self.t.start()
+        
+        self.gb = GraphiteBridge(server.server_address, self.registry, _time=FakeTime())
+
+    def test_nolabels(self):
+        counter = Counter('c', 'help', registry=self.registry)
+        counter.inc()
+
+        self.gb.push()
+        self.t.join()
+
+        self.assertEqual(b'c 1.0 1434898897\n', self.data)
+
+    def test_labels(self):
+        labels = Counter('labels', 'help', ['a', 'b'], registry=self.registry)
+        labels.labels('c', 'd').inc()
+
+        self.gb.push()
+        self.t.join()
+
+        self.assertEqual(b'labels.a.c.b.d 1.0 1434898897\n', self.data)
+
+    def test_sanitizing(self):
+        labels = Counter('labels', 'help', ['a'], registry=self.registry)
+        labels.labels('c.:8').inc()
+
+        self.gb.push()
+        self.t.join()
+
+        self.assertEqual(b'labels.a.c__8 1.0 1434898897\n', self.data)

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +build
 +dist
 +*.egg-info
 +*.pyc
 +*.swp