async def test_compute_rollover_daily(self):
current_time = 0
handler = AsyncTimedRotatingFileHandler(
self.temp_file.name,
when=RolloverInterval.MIDNIGHT,
interval=1,
backup_count=0,
utc=True,
)
try:
actual = handler.compute_rollover(current_time)
self.assertEqual(actual, current_time + ONE_DAY_IN_SECONDS)
finally:
await handler.close()
async def test_rollover_happens_before_a_logline_is_emitted(self):
handler = AsyncTimedRotatingFileHandler(
filename=self.temp_file.name,
when=RolloverInterval.SECONDS,
backup_count=1,
)
formatter = Formatter("%(asctime)s %(message)s")
handler.formatter = formatter
self.assertTrue(os.path.exists(self.temp_file.name))
await asyncio.sleep(1.1)
record = make_log_record(msg="testing - initial")
await handler.emit(record)
await handler.close()
async def test_rollover_deletes_the_next_destination_file_path_if_it_already_exists(
self):
with freeze_time("2019-01-20 20:22:49") as frozen_datetime:
with patch(
"aiologger.handlers.files.os.stat",
return_value=Mock(
st_mtime=frozen_datetime.time_to_freeze.timestamp() -
time.altzone),
), patch("aiologger.handlers.files.os.unlink") as unlink:
new_file_path = f"{self.temp_file.name}.2019-01-20_20-22-49"
os.open(new_file_path, os.O_CREAT)
self.assertTrue(os.path.exists(new_file_path))
handler = AsyncTimedRotatingFileHandler(
filename=self.temp_file.name,
when=RolloverInterval.SECONDS,
backup_count=1,
utc=True,
)
frozen_datetime.tick()
await handler.emit(self.log_record)
unlink.assert_called_once_with(new_file_path)
await handler.close()
async def test_files_to_delete_returns_an_empty_list_if_there_is_nothing_to_delete(
self):
handler = AsyncTimedRotatingFileHandler(
filename=self.temp_file.name,
when=RolloverInterval.SECONDS,
backup_count=1,
)
self.assertEqual(await handler.get_files_to_delete(), [])
async def test_compute_rollover_weekly_attime(self):
current_time = int(time.time())
today = current_time - current_time % 86400
at_time = datetime.time(12, 0, 0)
week_day = time.gmtime(today).tm_wday
for day, interval in enumerate(RolloverInterval.WEEK_DAYS):
handler = AsyncTimedRotatingFileHandler(
filename=self.temp_file.name,
when=interval,
interval=1,
backup_count=0,
utc=True,
at_time=at_time,
)
try:
if week_day > day:
# The rollover day has already passed this week, so we
# go over into next week
expected = 7 - week_day + day
else:
expected = day - week_day
# At this point expected is in days from now, convert to seconds
expected *= ONE_DAY_IN_SECONDS
# Add in the rollover time
expected += 12 * 60 * 60
# Add in adjustment for today
expected += today
actual = handler.compute_rollover(today)
self.assertEqual(actual,
expected,
msg=f"failed in timezone: {time.timezone}")
if day == week_day:
# goes into following week
expected += ONE_WEEK_IN_SECONDS
actual = handler.compute_rollover(today + 13 * 60 * 60)
self.assertEqual(actual,
expected,
msg=f"failed in timezone: {time.timezone}")
finally:
await handler.close()
def setup_custom_logger():
LOG_PATH = 'log'
FileUtils.create_folder_if_not_exists(LOG_PATH)
handler = AsyncTimedRotatingFileHandler(
filename="log/think.log",
when=RolloverInterval.HOURS,
backup_count=48,
)
formatter = logging.Formatter(
"[%(asctime)s] %(threadName)s - %(pathname)s %(funcName)s():%(lineno)d %(levelname)s %(message)s"
)
handler.formatter = formatter
logger = Logger.with_default_handlers(formatter=formatter)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
return logger
async def test_compute_rollover_daily_attime(self):
current_time = 0
at_time = datetime.time(12, 0, 0)
handler = AsyncTimedRotatingFileHandler(
self.temp_file.name,
when=RolloverInterval.MIDNIGHT,
interval=1,
backup_count=0,
utc=True,
at_time=at_time,
)
try:
actual = handler.compute_rollover(current_time)
self.assertEqual(actual, current_time + 12 * 60 * 60)
actual = handler.compute_rollover(current_time + 13 * 60 * 60)
self.assertEqual(actual, current_time + 36 * 60 * 60)
finally:
await handler.close()
async def test_initialization_with_hours_rollover_interval(self):
handler = AsyncTimedRotatingFileHandler(
filename="/a/random/filepath",
when=RolloverInterval.HOURS,
backup_count=1,
)
self.assertEqual(handler.interval, ONE_HOUR_IN_SECONDS)
self.assertEqual(handler.rollover_at,
int(time.time()) + ONE_HOUR_IN_SECONDS)
await handler.close()
async def test_delete_files(self):
handler = AsyncTimedRotatingFileHandler(
filename=self.temp_file.name,
when=RolloverInterval.SECONDS,
backup_count=1,
)
file_paths = [NamedTemporaryFile(delete=False).name for _ in range(3)]
await handler._delete_files(file_paths)
for file_path in file_paths:
self.assertFalse(os.path.exists(file_path))
async def test_rollover_delete_old_files(self):
with freeze_time() as frozen_datetime:
handler = AsyncTimedRotatingFileHandler(
filename=self.temp_file.name,
when=RolloverInterval.SECONDS,
backup_count=1,
)
with patch.object(handler, "_delete_files", CoroutineMock()):
for _ in range(3):
await handler.emit(self.log_record)
frozen_datetime.tick()
handler._delete_files.assert_awaited_once()
await handler.close()
async def test_rollover(self):
handler = AsyncTimedRotatingFileHandler(
filename=self.temp_file.name,
when=RolloverInterval.SECONDS,
backup_count=1,
)
formatter = logging.Formatter("%(asctime)s %(message)s")
handler.formatter = formatter
r1 = logging.makeLogRecord({"msg": "testing - initial"})
await handler.emit(r1)
self.assertTrue(os.path.exists(self.temp_file.name))
await asyncio.sleep(1.1)
r2 = logging.makeLogRecord({"msg": "testing - after delay"})
await handler.emit(r2)
await handler.close()
# At this point, we should have a recent rotated file which we
# can test for the existence of. However, in practice, on some
# machines which run really slowly, we don't know how far back
# in time to go to look for the log file. So, we go back a fair
# bit, and stop as soon as we see a rotated file. In theory this
# could of course still fail, but the chances are lower.
found = False
now = datetime.datetime.now()
GO_BACK = 5 * 60 # seconds
for secs in range(GO_BACK):
prev = now - datetime.timedelta(seconds=secs)
fn = self.temp_file.name + prev.strftime(".%Y-%m-%d_%H-%M-%S")
found = os.path.exists(fn)
if found:
self.files_to_remove.append(fn)
break
self.assertTrue(
found, msg=f"No rotated files found, went back {GO_BACK} seconds"
)
async def test_invalid_rotation_interval(self):
for invalid_interval in ("X", "W", "W7", "Xablau"):
with self.assertRaises(ValueError):
AsyncTimedRotatingFileHandler(filename=self.temp_file.name,
when=invalid_interval)
from aiologger.loggers.json import JsonLogger
from aiologger.handlers.files import AsyncTimedRotatingFileHandler
from aiologger.handlers.files import RolloverInterval
__all__ = ['build_sample_middleware']
MODEL_NAME = os.environ.get('model_name', None)
MODEL_VERSION = os.environ.get('model_version', None)
SAMPLE_LOG_BACKUP_COUNT = os.environ.get('model_sample_log_backup_count', 7)
sample_logger = JsonLogger(name='jcake', flatten=True)
api_logger = logging.getLogger("demo.predict")
handler = AsyncTimedRotatingFileHandler(filename="sample/sample",
backup_count=SAMPLE_LOG_BACKUP_COUNT,
when=RolloverInterval.DAYS,
encoding='utf-8')
sample_logger.add_handler(handler)
def build_sample_info(request_ms, request, response, model_name,
model_version):
"""
构造采样的信息.
该采样实现目前只支持POST类型的请求.
Args:
request_ms: 请求耗时(ms)
request: 请求信息
response: 响应结果
"""
