def timestat(stat, millis):
if not _is_setup():
log.info('STATSD_HOST or STATSD_PORT not set up')
return
client = Client(settings.STATSD_HOST, settings.STATSD_PORT)
client.timing(_statname(stat), millis)
log.info('timestat: %s %sm' % (_statname(stat), millis))
def __init__(self, min_level=NOTSET, include_loggers=NOTSET, exclude_loggers=NOTSET,
host=NOTSET, port=NOTSET, prefix=NOTSET, *args, **kwargs):
super(GraphiteProcessor, self).__init__(*args, **kwargs)
if min_level is NOTSET:
min_level = settings.GRAPIHTE_LEVEL
if include_loggers is NOTSET:
include_loggers = settings.GRAPHITE_INCLUDE_LOGGERS
if exclude_loggers is NOTSET:
exclude_loggers = settings.GRAPHITE_EXCLUDE_LOGGERS
if host is NOTSET:
host = settings.GRAPHITE_HOST
if port is NOTSET:
port = settings.GRAPHITE_PORT
if prefix is NOTSET:
prefix = settings.GRAPHITE_PREFIX
self.min_level = min_level
self.include_loggers = include_loggers
self.exclude_loggers = exclude_loggers
self.host = host
self.port = port
self.prefix = prefix
self.client = Client(host=self.host, port=self.port)
def decrstat(stat, count=1):
if not _is_setup():
log.info('STATSD_HOST or STATSD_PORT not set up')
return
client = Client(settings.STATSD_HOST, settings.STATSD_PORT)
client.decrement(_statname(stat), count)
log.info('decrstat: %s %s' % (_statname(stat), count))
def test_client_create(self):
host, port = ('example.com', 8888)
client = Client(host=host, port=port, prefix='pystatsd.tests')
self.assertEqual(client.host, host)
self.assertEqual(client.port, port)
self.assertEqual(client.prefix, 'pystatsd.tests')
self.assertEqual(client.addr, (socket.gethostbyname(host), port))
def addstat(stat, n):
if not _is_setup():
log.info('STATSD_HOST or STATSD_PORT not set up')
return
client = Client(settings.STATSD_HOST, settings.STATSD_PORT)
client.update_stats(_statname(stat), n)
log.info('addstat: %s %s' % (_statname(stat), n))
def setUp(self):
self.patchers = []
socket_patcher = mock.patch('pystatsd.statsd.socket.socket')
self.mock_socket = socket_patcher.start()
self.patchers.append(socket_patcher)
self.client = Client()
self.addr = (socket.gethostbyname(self.client.host), self.client.port)
def backend_statsd(url, stats, prefix):
from pystatsd import Client
process_num = stats['Process_num']
del (stats['Process_num'])
server_name = socket.getfqdn().split('.')[0]
prefix = '%s.%s.%s' % (prefix, server_name, int(process_num))
logger.debug('Reporting to prefix: %s' % prefix)
server, port = url.split(':')
try:
pystatsd_client = Client(host=server, port=port, prefix=prefix)
except Exception, e:
logger.error('Unable to connect to statsd backend %s: %s' % (url, e))
raise
def create_stats_client():
"Create the client which can be used for logging statistics"
logger = logging.getLogger("pystatsd.client")
logger.addHandler(logging.StreamHandler())
try:
stats_server = config.get("admin", {}).get("statsd_server", None)
if stats_server:
host, port = stats_server.rsplit(":", 1)
return Client(host, port)
else:
return False
except Exception:
#TBD : Log stats error here
return False
def create_stats_client(cfg=config):
"Create the client which can be used for logging statistics"
logger = logging.getLogger("pystatsd.client")
logger.addHandler(logging.StreamHandler())
try:
stats_server = cfg.get("admin", {}).get("statsd_server", None)
if stats_server:
host, port = stats_server.rsplit(":", 1)
return Client(host, port)
else:
logger.critical("Couldn't find statsd_server section in config")
return False
except Exception as e:
logger.critical("Couldn't create stats client - %s", e, exc_info=True)
return False
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
#
# Authors:
# - Luis Rodrigues, <*****@*****.**>, 2013
from pystatsd import Client
from rucio.common.config import config_get
import time
server = config_get('monitor', 'carbon_server')
port = config_get('monitor', 'carbon_port')
scope = config_get('monitor', 'user_scope')
pystatsd_client = Client(host=server, port=port, prefix=scope)
def record_counter(counters, delta=1):
"""
Log one or more counters by arbitrary amounts
:param counters: The counter or a list of counters to be updated.
:param delta: The increment for the counter, by default increment by 1.
"""
pystatsd_client.update_stats(counters, delta)
def record_gauge(stat, value):
"""
Log gauge information for a single stat
SERVER = config_get('monitor',
'carbon_server',
raise_exception=False,
default='statsd-exporter-rucio-statsd-exporter')
PORT = config_get('monitor',
'carbon_port',
raise_exception=False,
default=8125)
SCOPE = config_get('monitor',
'user_scope',
raise_exception=False,
default='rucio')
print('Instantiating default client with %s %s %s' % (SERVER, PORT, SCOPE))
CLIENT = Client(host=SERVER, port=PORT, prefix=SCOPE)
def record_counter(counters, delta=1):
"""
Log one or more counters by arbitrary amounts
:param counters: The counter or a list of counters to be updated.
:param delta: The increment for the counter, by default increment by 1.
"""
CLIENT.update_stats(counters, delta)
def record_gauge(stat, value):
"""
Log gauge information for a single stat
# coding=utf-8
from pystatsd import Client
sc = Client('example.org', 8125)
sc.timing('python_test.time', 500)
sc.increment('python_test.inc_int')
sc.decrement('python_test.decr_int')
sc.gauge('python_test.gauge', 42)
#!/usr/bin/env python
from pystatsd import Client, Server
sc = Client('localhost', 8125)
sc.timing('python_test.time', 500)
sc.increment('python_test.inc_int')
sc.decrement('python_test.decr_int')
srvr = Server(debug=True)
srvr.serve()
def main():
s = Client('localhost',8125)
n = LinuxNetStats()
for k,v in n.forStatsd(prefix='host.com.eeqj.net.').items():
s.update_stats(k,v)
class Metric(object):
"""
The metrics client that communicates with graphite via local pystatsd.
>>> from metrics import Metric
>>> Metric.add("foo.bar.baz")
>>> Metric.timing("foo.bar.millis", 123)
"""
_client = Client()
@classmethod
def _add_namespace(cls, name):
namespace = _config.get("namespace")
return "%s.%s" % (namespace, name) if namespace else name
@classmethod
def add(cls, name, delta=1):
"""
Updates a stats counter by arbitrary value (increments by one by default).
>>> Metric.add("foo.bar.baz") # increments by one
>>> Metric.add("baz.bar.foo", 10) # adds 10 to the stats counter
@param name: the stats key
@type name: str
@param delta: the value to update
@type delta: int
"""
if not cls._client:
return
if not name:
return
if not delta:
return
cls._client.update_stats(cls._add_namespace(name), delta)
@classmethod
def timing(cls, name, time):
"""
Submits time value for a given stats key.
>>> Metric.timing("execution.time.baz", 123)
@param name: the stats key
@type name: str
@param time: the time value to submit (in seconds)
@type time: int or float
"""
if not cls._client:
return
if not name:
return
if time:
time = float(time)
if not time:
return
millis = int(time * 1000 + .5)
cls._client.timing(cls._add_namespace(name), millis)
@classmethod
def start_timing(cls, name):
"""
Starts and returns a timing instance that tracks time for a given stats key. The stats
will be updated once done() is invoked on the returned timing instance.
>>> timer = Metric.start_timing("execution.time.baz")
>>> # do stuff here...
>>> timer.done() # submits stats
@param name: the stats key
@type name: str
@rtype: _Timing
"""
return _Timing(name)
#!/usr/bin/env python
from pystatsd import Client, Server
sc = Client('rayners.org',8125)
sc.timing('python_test.time',500)
sc.increment('python_test.inc_int')
sc.decrement('python_test.decr_int')
srvr = Server(debug=True)
srvr.serve()
def connect_node_js():
server = __config.get('carbon', 'carbon_server')
port = __config.get('carbon', 'carbon_port')
scope = __config.get('carbon', 'user_scope')
return Client(host=server, port=port, prefix=scope)
