qommon: added basic statsd infrastructure (#1862)

wcs/qommon/ident/password.ptl

@@ -206,14 +206,18 @@ class MethodDirectory(Directory):
         username = form.get_widget('username').parse()
         password = form.get_widget('password').parse()
 
+        get_publisher().statsd.increment('login-submit')
+
         try:
             user = PasswordAccount.get_with_credentials(username, password)
         except:
             form.set_error('username', _('Invalid credentials'))
+            get_publisher().statsd.increment('login-error')
             return
 
-        account = PasswordAccount.get(username)
+        get_publisher().statsd.increment('login-success')
 
+        account = PasswordAccount.get(username)
         return self.login_submit_account_user(account, user, form)
 
     def login_submit_account_user(self, account, user, form=None):

wcs/qommon/publisher.py

@@ -240,12 +240,18 @@ class QommonPublisher(Publisher):
             # this could happen on file descriptor exhaustion
             pass
 
+    def finish_successful_request(self):
+        Publisher.finish_successful_request(self)
+        self.statsd.increment('successful-request')
+
     def finish_failed_request(self):
         # duplicate at lot from parent class, just to use our own HTTPResponse
         request = get_request()
         original_response = request.response
         request.response = HTTPResponse()
 
+        self.statsd.increment('failed-request')
+
         (exc_type, exc_value, tb) = sys.exc_info()
 
         if exc_type is NotImplementedError:
@@ -452,6 +458,13 @@ class QommonPublisher(Publisher):
         except ImmediateRedirectException, e:
             return redirect(e.location)
 
+        from vendor import pystatsd
+        self.statsd = pystatsd.Client(
+                        host=request.get_environ('QOMMON_STATSD_HOSTNAME', 'localhost'),
+                        prefix='%s.%s' % (
+                                self.APP_NAME,
+                                os.path.split(self.app_dir)[-1].replace('+', '-').replace('.', '-')))
+
         self.initialize_app_dir()
 
         canonical_hostname = request.get_server(False).lower().split(':')[0].rstrip('.')

wcs/qommon/vendor/pystatsd.py

@@ -0,0 +1,113 @@
+# w.c.s. - web application for online forms
+# Copyright (C) 2005-2012  Entr'ouvert
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>.
+#
+#
+# statsd.py - Python implementation of the statsd client
+#
+# Initially released (as License :: OSI Approved :: BSD License, from setup.py)
+# by Steve Ivy <steveivy@gmail.com> - <https://github.com/sivy/py-statsd>
+
+import random
+import socket
+import time
+
+
+# Sends statistics to the stats daemon over UDP
+class Client(object):
+
+    def __init__(self, host='localhost', port=8125, prefix=None):
+        """
+        Create a new Statsd client.
+        * host: the host where statsd is listening, defaults to localhost
+        * port: the port where statsd is listening, defaults to 8125
+
+        >>> from pystatsd import statsd
+        >>> stats_client = statsd.Statsd(host, port)
+        """
+        self.addr = (socket.gethostbyname(host), port)
+        self.prefix = prefix
+        self.udp_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+
+    def timing_since(self, stat, start, sample_rate=1):
+        """
+        Log timing information as the number of microseconds since the provided time float
+        >>> start = time.time()
+        >>> # do stuff
+        >>> statsd_client.timing_since('some.time', start)
+        """
+        self.timing(stat, int((time.time() - start) * 1000000), sample_rate)
+
+    def timing(self, stat, time, sample_rate=1):
+        """
+        Log timing information for a single stat
+        >>> statsd_client.timing('some.time',500)
+        """
+        stats = {stat: "%f|ms" % time}
+        self.send(stats, sample_rate)
+
+    def gauge(self, stat, value, sample_rate=1):
+        """
+        Log gauge information for a single stat
+        >>> statsd_client.gauge('some.gauge',42)
+        """
+        stats = {stat: "%f|g" % value}
+        self.send(stats, sample_rate)
+
+    def increment(self, stats, sample_rate=1):
+        """
+        Increments one or more stats counters
+        >>> statsd_client.increment('some.int')
+        >>> statsd_client.increment('some.int',0.5)
+        """
+        self.update_stats(stats, 1, sample_rate=sample_rate)
+
+    def decrement(self, stats, sample_rate=1):
+        """
+        Decrements one or more stats counters
+        >>> statsd_client.decrement('some.int')
+        """
+        self.update_stats(stats, -1, sample_rate=sample_rate)
+
+    def update_stats(self, stats, delta, sample_rate=1):
+        """
+        Updates one or more stats counters by arbitrary amounts
+        >>> statsd_client.update_stats('some.int',10)
+        """
+        if not isinstance(stats, list):
+            stats = [stats]
+
+        data = dict((stat, "%s|c" % delta) for stat in stats)
+        self.send(data, sample_rate)
+
+    def send(self, data, sample_rate=1):
+        """
+        Squirt the metrics over UDP
+        """
+
+        if self.prefix:
+            data = dict((".".join((self.prefix, stat)), value) for stat, value in data.iteritems())
+
+        if sample_rate < 1:
+            if random.random() > sample_rate:
+                return
+            sampled_data = dict((stat, "%s|@%s" % (value, sample_rate)) for stat, value in data.iteritems())
+        else:
+            sampled_data = data
+
+        try:
+            [self.udp_sock.sendto("%s:%s" % (stat, value), self.addr) for stat, value in sampled_data.iteritems()]
+        except:
+            pass