Added context managers and decorators.

Author: Lispython

Makefile

@@ -33,7 +33,7 @@ publish: clean-pyc
 	$(DOCKER_RUN_COMMAND) "twine upload dist/*"
 	@echo ""
 
-test: clean-conteainers
+test: clean-containers
 	@echo "Test application $(version)"
 	$(DOCKER_RUN_COMMAND) "uwsgi --pyrun setup.py --pyargv test --sharedarea=100 --enable-threads"
 	@echo ""

README.rst

@@ -24,11 +24,11 @@ INSTALLATION
 
 To use pyprometheus use pip or easy_install:
 
-`pip install pyprometheus`
+:code:`pip install pyprometheus`
 
 or
 
-`easy_install pyprometheus`
+:code:`easy_install pyprometheus`
 
 
 HOW TO INSTRUMENTING CODE
@@ -44,11 +44,29 @@ A gauge is a metric that represents a single numerical value that can arbitraril
 
    storage = LocalMemoryStorage()
    registry = CollectorRegistry(storage=storage)
-   job_in_progress = Gauge("job_in_progress", "Description", registry=registry)
+   gauge = Gauge("job_in_progress", "Description", registry=registry)
+
+   gauge.inc(10)
+   gauge.dec(5)
+   gauge.set(21.1)
+
+
+utilities::
+
+  gauge.set_to_current_time()   # Set to current unixtime
+
+  # Increment when entered, decrement when exited.
+  @gauge.track_in_progress()
+  def f():
+      pass
+
+  with gauge.track_in_progress():
+      pass
+
+
+  with gauge.time():
+      time.sleep(10)
 
-   job_in_progress.inc(10)
-   job_in_progress.dec(5)
-   job_in_progress.set(21.1)
 
 
 Counter
@@ -61,9 +79,12 @@ A counter is a cumulative metric that represents a single numerical value that o
 
    storage = LocalMemoryStorage()
    registry = CollectorRegistry(storage=storage)
-   requests_total = Counter("requests_total", "Description", registry=registry)
+   counter = Counter("requests_total", "Description", registry=registry)
+
+   counter.inc(10)
+
+
 
-   requests_total.inc(10)
 
 
 Summary
@@ -81,6 +102,17 @@ Similar to a histogram, a summary samples observations (usually things like requ
    s.observe(0.100)
 
 
+utilities for timing code::
+
+   @gauge.time()
+   def func():
+      time.sleep(10)
+
+   with gauge.time():
+      time.sleep(10)
+
+
+
 Histogram
 ~~~~~~~~~
 
@@ -91,9 +123,19 @@ A histogram samples observations (usually things like request durations or respo
 
    storage = LocalMemoryStorage()
    registry = CollectorRegistry(storage=storage)
-   h = Histogram("requests_duration_seconds", "Description", registry=registry)
+   histogram = Histogram("requests_duration_seconds", "Description", registry=registry)
+
+   histogram.observe(1.1)
+
+utilities for timing code::
+
+   @histogram.time()
+   def func():
+      time.sleep(10)
+
+   with histogram.time():
+      time.sleep(10)
 
-   h.observe(1.1)
 
 
 Labels

docs/usage.rst

@@ -0,0 +1,2 @@
+HOW TO INSTRUMENTING CODE
+=========================

pyprometheus/managers.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+pyprometheus.values
+~~~~~~~~~~~~~~~~~~~
+
+Prometheus instrumentation library for Python applications
+
+:copyright: (c) 2017 by Alexandr Lispython.
+:license: , see LICENSE for more details.
+:github: http://github.com/Lispython/pyprometheus
+"""
+import time
+from functools import wraps
+
+default_timer = time.time
+
+class BaseManager(object):
+    def __call__(self, f):
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+            with self:
+                return f(*args, **kwargs)
+        return wrapper
+
+
+class TimerManager(BaseManager):
+    def __init__(self, collector):
+        self._collector = collector
+
+    def __enter__(self):
+        self._start_time = default_timer()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._collector.observe(default_timer() - self._start_time)
+
+
+class InprogressTrackerManager(BaseManager):
+
+    def __init__(self, gauge):
+        self._gauge = gauge
+
+    def __enter__(self):
+        self._gauge.inc()
+
+    def __exit__(self, exc_info, exc_value, traceback):
+        self._gauge.dec()
+
+
+class GaugeTimerManager(TimerManager):
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._collector.set(default_timer() - self._start_time)

pyprometheus/metrics.py

@@ -18,7 +18,6 @@
                                  CounterValue, SummaryValue,
                                  HistogramValue)
 
-
 class BaseMetric(object):
 
     value_class = MetricValue
@@ -27,6 +26,8 @@ class BaseMetric(object):
 
     TYPE = "untyped"
 
+    PARENT_METHODS = set()
+
     def __init__(self, name, doc, labels=[], registry=None):
         self._name = name
         self._doc = doc
@@ -45,7 +46,7 @@ def __repr__(self):
         return u"<{0}[{1}]: {2} samples>".format(self.__class__.__name__, self._name, len(self._samples))
 
     def get_proxy(self):
-        if self._labelsnames:
+        if self._labelnames:
             raise RuntimeError("You need to use labels")
         return self.value_class(self, label_values={})
 
@@ -123,23 +124,35 @@ def get_samples(self):
         return self._samples.values()
 
 
+    def __getattr__(self, name):
+        if name in self.PARENT_METHODS:
+            return getattr(self.get_proxy(), name)
+
+        raise AttributeError
+        # return super(BaseMetric, self).__getattr__(name)
+
+
+
+
+
+
 class Gauge(BaseMetric):
 
     TYPE = "gauge"
 
     value_class = GaugeValue
 
-    inc = property(BaseMetric.get_proxy)
-    dec = property(BaseMetric.get_proxy)
-    set = property(BaseMetric.get_proxy)
+    PARENT_METHODS = set(('inc', 'dec', 'set', 'get', 'track_inprogress',
+                      'set_to_current_time', 'time', 'value'))
+
 
 
 class Counter(BaseMetric):
     TYPE = "counter"
 
     value_class = CounterValue
 
-    inc = property(BaseMetric.get_proxy)
+    PARENT_METHODS = set(('inc', 'get', 'value'))
 
 
 class Summary(BaseMetric):
@@ -151,12 +164,12 @@ class Summary(BaseMetric):
 
     NOT_ALLOWED_LABELS = set('quantile')
 
+    PARENT_METHODS = set(('observe', 'value', 'time'))
+
     def __init__(self, name, doc, labels=[], quantiles=False, registry=None):
         self._quantiles = list(sorted(quantiles)) if quantiles else []
         super(Summary, self).__init__(name, doc, labels, registry)
 
-    observe = property(BaseMetric.get_proxy)
-
     @property
     def quantiles(self):
         return self._quantiles
@@ -193,12 +206,12 @@ class Histogram(BaseMetric):
 
     value_class = HistogramValue
 
+    PARENT_METHODS = set(('observe', 'value', 'time'))
+
     def __init__(self, name, doc, labels=[], buckets=DEFAULT_BUCKETS, registry=None):
         self._buckets = list(sorted(buckets)) if buckets else []
         super(Histogram, self).__init__(name, doc, labels, registry)
 
-    observe = property(BaseMetric.get_proxy)
-
     @property
     def buckets(self):
         return self._buckets

pyprometheus/values.py

@@ -15,7 +15,7 @@
 import time
 
 from pyprometheus.const import TYPES
-
+from pyprometheus.managers import TimerManager, InprogressTrackerManager, GaugeTimerManager
 
 class MetricValue(object):
     """Base metric collector
@@ -109,16 +109,26 @@ class GaugeValue(MetricValue):
 
     TYPE = TYPES.GAUGE
 
-    def dec(self, amount):
+    def dec(self, amount=1):
         self.inc(-amount)
 
     def set(self, value):
         self._metric._storage.write_value(self.key, value)
+        return value
 
     @property
     def value(self):
         return self.get()
 
+    def track_in_progress(self):
+        return InprogressTrackerManager(self)
+
+    def set_to_current_time(self):
+        return self.set(time.time())
+
+    def time(self):
+        return GaugeTimerManager(self)
+
 
 class CounterValue(MetricValue):
 
@@ -231,6 +241,9 @@ def export_str(self):
         return "\n".join([self._sum.export_str, self._count.export_str] + [quantile.export_str for quantile in self._quantiles])
 
 
+    def time(self):
+        return TimerManager(self)
+
 
 class HistogramCountValue(SummaryCountValue):
     TYPE = TYPES.HISTOGRAM_COUNTER
@@ -319,3 +332,7 @@ def value(self):
     @property
     def export_str(self):
         return "\n".join([self._sum.export_str, self._count.export_str] + [bucket.export_str for bucket in self._buckets])
+
+
+    def time(self):
+        return TimerManager(self)