def test_data_collector(self):
scriptname = "foo"
hostname = "bar"
schema = "http"
tags = {"baz": "qux"}
collector = DataCollector(scriptname, hostname, schema, tags)
assert collector.enabled is True
assert collector.timers == set()
assert collector.scriptname == scriptname
assert collector.hostname == hostname
assert collector.schema == schema
assert collector.tags == tags
assert collector.dt_start is None
assert collector.started is False
assert collector.elapsed is None
with self.assertRaises(RuntimeError):
collector.stop()
collector.start()
assert collector.started is True
assert collector.elapsed is None
with self.assertRaises(RuntimeError):
collector.start()
collector.stop()
assert collector.elapsed is not None
def push(self):
"""Pushes current context into local stack.
"""
self.pynba = DataCollector(self._scriptname,
self._hostname,
self._schema,
self.config.get('tags', {}))
self.pynba.start()
LOCAL_STACK.pynba = self.pynba
self.resources = resource.getrusage(resource.RUSAGE_SELF)
def __init__(self,
address,
hostname=None,
scriptname=None,
servername=None,
reporter=None,
tags=None,
autostart=True):
self.reporter = reporter or self.default_reporter(address)
self.collector = DataCollector(tags=tags or {})
self.hostname = hostname or socket.gethostname()
self.scriptname = scriptname or " ".join(sys.argv)
self.servername = servername or socket.gethostname()
self.resources = None
self.ru_utime = None
self.ru_stime = None
if autostart:
self.start()
def __init__(self, address, hostname=None, scriptname=None,
servername=None, reporter=None, tags=None, autostart=True):
self.reporter = reporter or self.default_reporter(address)
self.collector = DataCollector(tags=tags or {})
self.hostname = hostname or socket.gethostname()
self.scriptname = scriptname or " ".join(sys.argv)
self.servername = servername or socket.gethostname()
self.resources = None
self.ru_utime = None
self.ru_stime = None
if autostart:
self.start()
def test_linked_timer(self):
collector = DataCollector()
timer = collector.timer(foo='bar')
assert timer in collector.timers
cloned = timer.clone()
assert cloned in collector.timers
timer.delete()
assert timer not in collector.timers
assert cloned in collector.timers
cloned.delete()
assert cloned not in collector.timers
timer2 = collector.timer(foo='bar')
assert timer2 in collector.timers
collector.flush()
assert timer2 not in collector.timers
class ScriptMonitor(object):
"""Helper for monitoring standalone scripts.
>>> monitor = ScriptMonitor(('127.0.0.1', 30002))
>>> timer = monitor.timer(tag1='bar')
>>> timer.start()
>>> timer.stop()
>>>
>>> @monitor.timer(tag1='bar')
>>> def baz():
>>> pass
>>> baz()
>>>
>>> with monitor.timer(tag1='baz'):
>>> print "hello"
>>>
>>> monitor.send()
"""
default_reporter = Reporter
def __init__(self, address, hostname=None, scriptname=None,
servername=None, reporter=None, tags=None, autostart=True):
self.reporter = reporter or self.default_reporter(address)
self.collector = DataCollector(tags=tags or {})
self.hostname = hostname or socket.gethostname()
self.scriptname = scriptname or " ".join(sys.argv)
self.servername = servername or socket.gethostname()
self.resources = None
self.ru_utime = None
self.ru_stime = None
if autostart:
self.start()
@property
def started(self):
return self.collector.started
@property
def elapsed(self):
return self.collector.elapsed
def start(self):
"""Starts monitoring.
"""
self.collector.start()
self.resources = resource.getrusage(resource.RUSAGE_SELF)
return self
def stop(self):
"""Stops current elapsed time and every attached timers.
"""
self.collector.stop()
usage = resource.getrusage(resource.RUSAGE_SELF)
self.ru_utime = usage.ru_utime - self.resources.ru_utime
self.ru_stime = usage.ru_stime - self.resources.ru_stime
return self
@property
def tags(self):
"""Returns collector tags.
"""
return self.collector.tags
def timer(self, **kwargs):
"""Factory new timer.
"""
return self.collector.timer(**kwargs)
def flush(self):
"""Flushes timers.
"""
self.collector.flush()
return self
def send(self):
"""Sends timers to server.
"""
self.stop()
timers = [timer for timer in self.collector.timers if timer.elapsed]
document_size = self.collector.document_size
memory_peak = self.collector.memory_peak
ru_utime = self.ru_utime
ru_stime = self.ru_stime
self.reporter(
self.servername,
self.hostname,
self.scriptname,
self.collector.elapsed,
timers,
ru_utime=ru_utime,
ru_stime=ru_stime,
document_size=document_size,
memory_peak=memory_peak,
status=None,
memory_footprint=None,
schema=None,
tags=self.collector.tags
)
self.flush()
class RequestContext(object):
"""
A new instance will be created every new request.
:param reporter: a :class:`Reporter` instance
:param environ: the current WSGI environ mapping
:param config: may have these keys:
``prefix`` will prepend scriptname
"""
def __init__(self, reporter, environ, **config):
self.reporter = reporter
#: config['prefix'] prepends the sent scriptname to pinba.
#: config['tags'] prepends tags to pinba.
self.config = config
#: futur :class:`DataCollector`
self.pynba = None
#: will keep a snap of :func:`resource.getrusage`
self.resources = None
self._hostname = environ.get('SERVER_NAME', None)
self._schema = environ.get('wsgi.url_scheme', None)
self._scriptname = environ.get('PATH_INFO', '')
self._servername = ''
@property
def scriptname(self):
out = self.config.get('prefix', '')
if self.pynba:
pynba = self.pynba
if pynba.scriptname:
return out + self.pynba.scriptname
return out + self._scriptname
@property
def hostname(self):
if self.pynba:
pynba = self.pynba
if pynba.hostname:
return pynba.hostname
if self._hostname:
return self._hostname
return None
@property
def servername(self):
return self._servername
@property
def tags(self):
if self.pynba:
pynba = self.pynba
response = pynba.tags or {}
else:
response = self.config.get('tags', {})
return response
def push(self):
"""Pushes current context into local stack.
"""
self.pynba = DataCollector(self._scriptname,
self._hostname,
self._schema,
self.config.get('tags', {}))
self.pynba.start()
LOCAL_STACK.pynba = self.pynba
self.resources = resource.getrusage(resource.RUSAGE_SELF)
def pop(self):
"""Pops current context from local stack.
"""
del LOCAL_STACK.pynba
self.pynba = None
self.resources = None
def __enter__(self):
"""Opens current scope.
"""
self.push()
return self
def __exit__(self, exc_type, exc_value, traceback):
"""Closes current scope.
"""
self.flush()
self.pop()
def flush(self):
"""Flushes timers.
Similar to the PHP ``pinba_flush()`` function.
scriptname sent to pinba will be prepend by config['prefix']
"""
if not self.pynba or not self.pynba.enabled:
return
self.pynba.stop()
timers = [timer for timer in self.pynba.timers if timer.elapsed]
document_size = self.pynba.document_size
memory_peak = self.pynba.memory_peak
usage = resource.getrusage(resource.RUSAGE_SELF)
ru_utime = usage.ru_utime - self.resources.ru_utime
ru_stime = usage.ru_stime - self.resources.ru_stime
memory_footprint = self.pynba.memory_peak
schema = self.pynba.schema
self.reporter(
self.servername,
self.hostname,
self.scriptname,
self.pynba.elapsed,
timers,
ru_utime=ru_utime,
ru_stime=ru_stime,
document_size=document_size,
memory_peak=memory_peak,
memory_footprint=memory_footprint,
schema=schema,
tags=self.tags
)
self.pynba.flush()
def test_collector(self):
DataCollector().flush()
assert self.handler.messages == {'debug': ['flush']}
class ScriptMonitor(object):
"""Helper for monitoring standalone scripts.
>>> monitor = ScriptMonitor(('127.0.0.1', 30002))
>>> timer = monitor.timer(tag1='bar')
>>> timer.start()
>>> timer.stop()
>>>
>>> @monitor.timer(tag1='bar')
>>> def baz():
>>> pass
>>> baz()
>>>
>>> with monitor.timer(tag1='baz'):
>>> print "hello"
>>>
>>> monitor.send()
"""
default_reporter = Reporter
def __init__(self,
address,
hostname=None,
scriptname=None,
servername=None,
reporter=None,
tags=None,
autostart=True):
self.reporter = reporter or self.default_reporter(address)
self.collector = DataCollector(tags=tags or {})
self.hostname = hostname or socket.gethostname()
self.scriptname = scriptname or " ".join(sys.argv)
self.servername = servername or socket.gethostname()
self.resources = None
self.ru_utime = None
self.ru_stime = None
if autostart:
self.start()
@property
def started(self):
return self.collector.started
@property
def elapsed(self):
return self.collector.elapsed
def start(self):
"""Starts monitoring.
"""
self.collector.start()
self.resources = resource.getrusage(resource.RUSAGE_SELF)
return self
def stop(self):
"""Stops current elapsed time and every attached timers.
"""
self.collector.stop()
usage = resource.getrusage(resource.RUSAGE_SELF)
self.ru_utime = usage.ru_utime - self.resources.ru_utime
self.ru_stime = usage.ru_stime - self.resources.ru_stime
return self
@property
def tags(self):
"""Returns collector tags.
"""
return self.collector.tags
def timer(self, **kwargs):
"""Factory new timer.
"""
return self.collector.timer(**kwargs)
def flush(self):
"""Flushes timers.
"""
self.collector.flush()
return self
def send(self):
"""Sends timers to server.
"""
self.stop()
timers = [timer for timer in self.collector.timers if timer.elapsed]
document_size = self.collector.document_size
memory_peak = self.collector.memory_peak
ru_utime = self.ru_utime
ru_stime = self.ru_stime
self.reporter(self.servername,
self.hostname,
self.scriptname,
self.collector.elapsed,
timers,
ru_utime=ru_utime,
ru_stime=ru_stime,
document_size=document_size,
memory_peak=memory_peak,
status=None,
memory_footprint=None,
schema=None,
tags=self.collector.tags)
self.flush()
