File size: 3,503 Bytes
f31fe4e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 | # coding: utf-8
from __future__ import absolute_import, division, print_function, unicode_literals
import functools
import logging
import threading
import time
from typing import Callable, Optional
import bytedenv
import schedule
metrics_enabled = None
logger = logging.getLogger(__name__)
logging.getLogger('schedule').setLevel(logging.ERROR)
class Backgrounds(object):
def __init__(self): # type: () -> None
self.scheduler = schedule.Scheduler()
self.lock = threading.Lock()
self.init_closures = []
self.stop_event = threading.Event()
def register(self, schedule_seconds, closure, init_closure=None):
# type: (int, Callable[[], None], Optional[Callable[[], None]]) -> None
""" Register a background task.
:param schedule_seconds: The schedule time in seconds for this task.
:param closure: Closure for the task, will running periodically. If this closure raised any error, the error
will be handled by a logger.
:param init_closure: Closure for task's initialize, will be called once after start(). If this closure raised
any error, the error will popuped to the start() method.
"""
@functools.wraps(closure)
def wrapper():
start = time.time()
try:
closure()
except Exception:
logger.exception('run %s in background raised an error, the backtrace is:', closure)
time_usage = time.time() - start
logger.debug('run %s in background, time usage in seconds: %f', closure, time_usage)
if time_usage > 3:
logger.warning(
'time usage in seconds for run %s in background is %f, this may cause other task delay',
closure, time_usage
)
tags = {'task_name': getattr(closure, '__name__', 'unknown')}
global metrics_enabled
if metrics_enabled is None:
try:
from bytedance import metrics
metrics_enabled = True
except ImportError:
metrics_enabled = False
if metrics_enabled:
from bytedance import metrics
metrics.emit_counter('python.backgrounds.%s.delay' % bytedenv.get_psm(), 1, tags=tags)
with self.lock:
self.scheduler.every(schedule_seconds).seconds.do(wrapper)
if init_closure:
self.init_closures.append(init_closure)
def _target(self): # type: () -> None
while True:
if self.stop_event.is_set():
break
self.scheduler.run_pending()
time.sleep(1)
def start(self): # type: () -> None
"""Start the backgrounds. **NOTICE**: you should call the start AFTER FORK!
"""
for closure in self.init_closures:
closure()
self.worker_thread = threading.Thread(target=self._target)
self.worker_thread.setDaemon(True)
self.worker_thread.setName('backgrounds')
self.worker_thread.start()
def stop(self): # type: () -> None
"""Stop the backgrounds.
"""
self.stop_event.set()
def join(self): # type: () -> None
"""Join the backgrounds' thread, will be blocked until stop() is called.
"""
return self.worker_thread.join()
|