def flush_next(self):
if len(self._trs_to_flush) > 0:
td = self._last_flush + self._THROTTLING_DELAY - datetime.now()
# Python 2.7 has this built in, python < 2.7 don't...
if hasattr(td,'total_seconds'):
delay = td.total_seconds()
else:
delay = (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10.0**6
if delay <= 0:
tr = self._trs_to_flush.pop()
self._last_flush = datetime.now()
log.debug("Flushing transaction %d" % tr.get_id())
try:
tr.flush()
except Exception,e :
log.exception(e)
self.tr_error(tr)
self.flush_next()
else:
# Wait a little bit more
tornado_ioloop = get_tornado_ioloop()
if tornado_ioloop._running:
tornado_ioloop.add_timeout(time.time() + delay,
lambda: self.flush_next())
elif self._flush_without_ioloop:
# Tornado is no started (ie, unittests), do it manually: BLOCKING
time.sleep(delay)
self.flush_next()
def flush_next(self):
if len(self._trs_to_flush) > 0:
td = self._last_flush + self._THROTTLING_DELAY - datetime.utcnow()
if hasattr(td, 'total_seconds'):
delay = td.total_seconds()
else:
delay = (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10 ** 6) / 10.0 ** 6
if delay <= 0:
tr = self._trs_to_flush.pop()
self._last_flush = datetime.utcnow()
log.debug("Flushing transaction %d" % tr.get_id())
try:
tr.flush()
except Exception, e:
log.exception(e)
self.tr_error(tr)
self.flush_next()
else:
tornado_ioloop = get_tornado_ioloop()
if tornado_ioloop._running:
tornado_ioloop.add_timeout(time.time() + delay,
lambda: self.flush_next())
elif self._flush_without_ioloop:
time.sleep(delay)
self.flush_next()
def flush_next(self):
if len(self._trs_to_flush) > 0:
td = self._last_flush + self._THROTTLING_DELAY - datetime.utcnow()
# Python 2.7 has this built in, python < 2.7 don't...
if hasattr(td, 'total_seconds'):
delay = td.total_seconds()
else:
delay = (td.microseconds +
(td.seconds + td.days * 24 * 3600) * 10**6) / 10.0**6
if delay <= 0:
tr = self._trs_to_flush.pop()
self._last_flush = datetime.utcnow()
log.debug("Flushing transaction %d" % tr.get_id())
try:
tr.flush()
except Exception, e:
log.exception(e)
self.tr_error(tr)
self.flush_next()
else:
# Wait a little bit more
tornado_ioloop = get_tornado_ioloop()
if tornado_ioloop._running:
tornado_ioloop.add_timeout(time.time() + delay,
lambda: self.flush_next())
elif self._flush_without_ioloop:
# Tornado is no started (ie, unittests), do it manually: BLOCKING
time.sleep(delay)
self.flush_next()
def run_pup(config):
""" Run the pup server. """
global port
port = config.get('pup_port', 17125)
interface = config.get('pup_interface', 'localhost')
if config.get('non_local_traffic', False) is True:
application.listen(port)
else:
# localhost in lieu of 127.0.0.1 allows for ipv6
application.listen(port, address=interface)
io_loop = get_tornado_ioloop()
io_loop.start()
def run_pup(config):
""" Run the pup server. """
global port
port = config.get('pup_port', 17125)
interface = config.get('pup_interface', 'localhost')
if config.get('non_local_traffic', False) is True:
application.listen(port)
else:
# localhost in lieu of 127.0.0.1 allows for ipv6
application.listen(port, address=interface)
io_loop = get_tornado_ioloop()
io_loop.start()
def run_pup(config):
""" Run the pup server. """
global port
port = config.get('pup_port', 17125)
interface = config.get('pup_interface', 'localhost')
if config.get('non_local_traffic', False) is True:
application.listen(port)
else:
# localhost in lieu of 127.0.0.1 allows for ipv6
application.listen(port, address=interface)
interval_ms = 2000
io_loop = get_tornado_ioloop()
scheduler = ioloop.PeriodicCallback(send_metrics, interval_ms, io_loop=io_loop)
scheduler.start()
io_loop.start()
def run_pup(config):
""" Run the pup server. """
global port
port = config.get('pup_port', 17125)
interface = config.get('pup_interface', 'localhost')
if config.get('non_local_traffic', False) is True:
application.listen(port)
else:
# localhost in lieu of 127.0.0.1 allows for ipv6
application.listen(port, address=interface)
interval_ms = 2000
io_loop = get_tornado_ioloop()
scheduler = ioloop.PeriodicCallback(send_metrics,
interval_ms,
io_loop=io_loop)
scheduler.start()
io_loop.start()
def flush_next(self):
if self._trs_to_flush is not None and len(self._trs_to_flush) > 0:
td = self._last_flush + self._THROTTLING_DELAY - datetime.utcnow()
delay = td.total_seconds()
if delay <= 0 and self._running_flushes < self._MAX_PARALLELISM:
tr = self._trs_to_flush.pop()
self._running_flushes += 1
self._last_flush = datetime.utcnow()
log.debug("Flushing transaction %d", tr.get_id())
try:
tr.flush()
except Exception as e:
log.exception(e)
self.tr_error(tr)
self.flush_next()
# Every running flushes relaunches a flush once it's finished
# If we are already at MAX_PARALLELISM, do nothing
# Otherwise, schedule a flush as soon as possible (throttling)
elif self._running_flushes < self._MAX_PARALLELISM:
# Wait a little bit more
tornado_ioloop = get_tornado_ioloop()
if tornado_ioloop._running:
tornado_ioloop.add_timeout(time.time() + delay,
lambda: self.flush_next())
elif self._flush_without_ioloop:
# Tornado is no started (ie, unittests), do it manually: BLOCKING
time.sleep(delay)
self.flush_next()
# Setting self._trs_to_flush to None means the flush is over.
# So it is oly set when there is no more running flushes.
# (which corresponds to the last flush calling flush_next)
elif self._running_flushes == 0:
self._trs_to_flush = None
log.debug('Flush %s took %ss (%s transactions)',
self._flush_count,
(datetime.utcnow() - self._flush_time).total_seconds(),
self._finished_flushes)
else:
log.debug("Flush in progress, %s flushes running", self._running_flushes)
if "Errno 99" in str(e):
log.warning("IPv6 doesn't seem to be fully supported. Falling back to IPv4")
http_server.listen(self._port, address="127.0.0.1")
else:
raise
except socket_error, e:
log.exception("Socket error %s. Is another application listening on the same port ? Exiting", e)
sys.exit(1)
except Exception, e:
log.exception("Uncaught exception. Forwarder is exiting.")
sys.exit(1)
log.info("Listening on port %d" % self._port)
# Register callbacks
self.mloop = get_tornado_ioloop()
logging.getLogger().setLevel(get_logging_config()['log_level'] or logging.INFO)
def flush_trs():
if self._watchdog:
self._watchdog.reset()
self._postMetrics()
self._tr_manager.flush()
tr_sched = tornado.ioloop.PeriodicCallback(flush_trs, TRANSACTION_FLUSH_INTERVAL,
io_loop=self.mloop)
# Register optional Graphite listener
gport = self._agentConfig.get("graphite_listen_port", None)
if gport is not None:
def stop():
""" Only used by the Windows service """
get_tornado_ioloop(ioloop, tornado.version_info).stop()
def run(self):
handlers = [
(r"/intake/?", AgentInputHandler),
(r"/api/v1/series/?", ApiInputHandler),
(r"/status/?", StatusHandler),
]
settings = dict(
cookie_secret="12oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
xsrf_cookies=False,
debug=False,
log_function=self.log_request
)
non_local_traffic = self._agentConfig.get("non_local_traffic", False)
tornado.web.Application.__init__(self, handlers, **settings)
http_server = tornado.httpserver.HTTPServer(self)
# non_local_traffic must be == True to match, not just some non-false value
if non_local_traffic is True:
http_server.listen(self._port)
else:
# localhost in lieu of 127.0.0.1 to support IPv6
try:
http_server.listen(self._port, address = "localhost")
except gaierror:
log.warning("Warning localhost seems undefined in your host file, using 127.0.0.1 instead")
http_server.listen(self._port, address = "127.0.0.1")
log.info("Listening on port %d" % self._port)
# Register callbacks
self.mloop = get_tornado_ioloop()
logging.getLogger().setLevel(get_logging_config()['log_level'] or logging.INFO)
def flush_trs():
if self._watchdog:
self._watchdog.reset()
self._postMetrics()
self._tr_manager.flush()
tr_sched = tornado.ioloop.PeriodicCallback(flush_trs,TRANSACTION_FLUSH_INTERVAL,
io_loop = self.mloop)
# Register optional Graphite listener
gport = self._agentConfig.get("graphite_listen_port", None)
if gport is not None:
log.info("Starting graphite listener on port %s" % gport)
from graphite import GraphiteServer
gs = GraphiteServer(self, get_hostname(self._agentConfig), io_loop=self.mloop)
if non_local_traffic is True:
gs.listen(gport)
else:
gs.listen(gport, address = "localhost")
# Start everything
if self._watchdog:
self._watchdog.reset()
tr_sched.start()
self.mloop.start()
log.info("Stopped")
def stop():
""" Only used by the Windows service """
get_tornado_ioloop().stop()
def run(self):
handlers = [
(r"/intake/?", AgentInputHandler),
(r"/intake/metrics?", MetricsAgentInputHandler),
(r"/intake/metadata?", MetadataAgentInputHandler),
(r"/api/v1/series/?", ApiInputHandler),
(r"/api/v1/check_run/?", ApiCheckRunHandler),
(r"/status/?", StatusHandler),
]
settings = dict(
cookie_secret="12oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
xsrf_cookies=False,
debug=False,
log_function=self.log_request)
non_local_traffic = self._agentConfig.get("non_local_traffic", False)
tornado.web.Application.__init__(self, handlers, **settings)
http_server = tornado.httpserver.HTTPServer(self)
try:
# non_local_traffic must be == True to match, not just some non-false value
if non_local_traffic is True:
http_server.listen(self._port)
else:
# localhost in lieu of 127.0.0.1 to support IPv6
try:
http_server.listen(self._port,
address=self._agentConfig['bind_host'])
except gaierror:
log.warning(
"localhost seems undefined in your host file, using 127.0.0.1 instead"
)
http_server.listen(self._port, address="127.0.0.1")
except socket_error as e:
if "Errno 99" in str(e):
log.warning(
"IPv6 doesn't seem to be fully supported. Falling back to IPv4"
)
http_server.listen(self._port, address="127.0.0.1")
else:
raise
except socket_error as e:
log.exception(
"Socket error %s. Is another application listening on the same port ? Exiting",
e)
sys.exit(1)
except Exception as e:
log.exception("Uncaught exception. Forwarder is exiting.")
sys.exit(1)
log.info("Listening on port %d" % self._port)
# Register callbacks
self.mloop = get_tornado_ioloop()
logging.getLogger().setLevel(get_logging_config()['log_level']
or logging.INFO)
def flush_trs():
if self._watchdog:
self._watchdog.reset()
self._postMetrics()
self._tr_manager.flush()
tr_sched = tornado.ioloop.PeriodicCallback(flush_trs,
TRANSACTION_FLUSH_INTERVAL,
io_loop=self.mloop)
# Register optional Graphite listener
gport = self._agentConfig.get("graphite_listen_port", None)
if gport is not None:
log.info("Starting graphite listener on port %s" % gport)
from graphite import GraphiteServer
gs = GraphiteServer(self,
get_hostname(self._agentConfig),
io_loop=self.mloop)
if non_local_traffic is True:
gs.listen(gport)
else:
gs.listen(gport, address="localhost")
# Start everything
if self._watchdog:
self._watchdog.reset()
tr_sched.start()
self.mloop.start()
log.info("Stopped")
def stop():
""" Only used by the Windows service """
get_tornado_ioloop().stop()
def stop():
""" Only used by the Windows service """
get_tornado_ioloop(ioloop, tornado.version_info).stop()
