async def test_writer_is_initialized_only_once(self): handler = AsyncFileHandler(filename=self.temp_file.name) with patch("aiologger.handlers.files.aiofiles.open", CoroutineMock()) as open: await asyncio.gather(*(handler.emit(self.record) for _ in range(42))) open.assert_awaited_once()
async def test_close_closes_the_file(self): handler = AsyncFileHandler(filename=self.temp_file.name) await handler._init_writer() self.assertFalse(handler.stream.closed) await handler.close() self.assertTrue(handler.stream.closed)
async def test_init_stream_initializes_a_nonblocking_file_writer(self): handler = AsyncFileHandler(filename=self.temp_file.name) await handler._init_writer() self.assertIsInstance(handler.stream, AsyncTextIOWrapper) self.assertFalse(handler.stream.closed) self.assertEqual(handler.stream._file.name, self.temp_file.name)
async def scrape_channel(channel, start, file, limit=None): logger = JsonLogger() handler = AsyncFileHandler(filename=file) logger.add_handler(handler) limit = int(limit) if limit and limit.isdigit() else None async for m in channel.history(limit=limit): logger = await log_message(m, logger=logger) await logger.shutdown() return file, int(time.time() - start)
async def test_close_closes_the_file(self): handler = AsyncFileHandler(filename=self.temp_file.name) await handler._init_writer() self.assertFalse(handler.stream is None) self.assertIsInstance(handler.stream, AsyncTextIOWrapper) self.assertFalse(handler.stream.closed) await handler.close() self.assertTrue(handler.stream is None)
async def test_emit_writes_log_records_into_the_file(self): handler = AsyncFileHandler(filename=self.temp_file.name) await handler.emit(self.record) await handler.emit(self.record) with open(self.temp_file.name) as fp: content = fp.read() self.assertEqual(content, "Xablau!\nXablau!\n")
def make_logger(config: Mapping[str, Any]) -> Logger: """ Create Logger instance for using async logging """ handler = AsyncFileHandler( filename=str(LOGS_PATH.joinpath(f'{config["filename"]}.log')), encoding='utf-8' ) logger = Logger( name=config['name'], level=config['level'], ) logger.add_handler(handler) return logger
async def test_initialization(self): encoding = "utf-8" mode = "x" handler = AsyncFileHandler( filename=self.temp_file.name, mode=mode, encoding=encoding ) self.assertIsInstance(handler, AsyncStreamHandler) self.assertEqual(handler.absolute_file_path, self.temp_file.name) self.assertEqual(handler.mode, mode) self.assertEqual(handler.encoding, encoding) self.assertIsNone(handler.stream)
def get_logger(cls, configuration: dict, name: str, path: str, level: str = 'NOTSET'): logger = cls(name=name, level=level) if 'stream' in configuration: configuration_handler = configuration['stream'] level = NAME_TO_LEVEL[configuration_handler['level']] formatter = cls._get_formatter( handler_configuration=configuration_handler) logger.add_handler( AsyncStreamHandler( stream=sys.stdout, level=level, formatter=formatter, filter=StdoutFilter(), )) logger.add_handler( AsyncStreamHandler( stream=sys.stderr, level=max(LogLevel.WARNING, level), formatter=formatter, )) if 'file' in configuration: logger.add_handler( AsyncFileHandler( filename=os.path.join(path, cls.LOG_FILENAME))) if 'smtp' in configuration: configuration_handler = configuration['smtp'] logger.add_handler( AsyncSMTPHandler( level=configuration_handler['level'], sender=configuration_handler['sender'], recipients=configuration_handler['recipients'], subject=configuration_handler['subject'], username=configuration_handler['username'], password=configuration_handler['password'], hostname=configuration_handler['hostname'], port=configuration_handler['port'], use_tls=configuration_handler['use_tls'], )) return logger
async def test_it_calls_handler_error_if_emit_fails(self): temp_file = NamedTemporaryFile(delete=False) handler = AsyncFileHandler(temp_file.name) log_record = LogRecord( name="Xablau", level=20, pathname="/aiologger/tests/test_logger.py", lineno=17, msg="Xablau!", exc_info=None, args=None, ) await handler._init_writer() exc = Exception("Xablau") with patch.object(handler.stream, "write", side_effect=exc), patch.object( handler, "handle_error", CoroutineMock()) as handle_error: await handler.emit(log_record) handle_error.assert_awaited_once_with(log_record, exc)
import json import asyncio import discord from aiologger.loggers.json import JsonLogger from aiologger.handlers.files import AsyncFileHandler logger = JsonLogger() handler = AsyncFileHandler(filename="./epic/import/history/message_dump.json") logger.add_handler(handler) def get_author(author): return ({ "name": author.name, "discriminator": author.discriminator, "bot": author.bot, "icon_url": getattr(author, "icon_url", None), "guild": { "name": author.guild.name, "id": author.guild.id, } if getattr(author, "guild", None) else None, } if author else None) def get_field(field): return { "name": getattr(field, "name", None), "value": getattr(field, "value", None), "inline": getattr(field, "inline", False), }
async def test_init_gets_the_running_event_loop(self): handler = AsyncFileHandler(filename=self.temp_file.name) self.assertIsInstance(handler.loop, asyncio.AbstractEventLoop)
import sys from pathlib import Path from loguru import logger import json ######################################## import asyncio import aiologger as logging from aiologger import Logger from aiologger.handlers.files import AsyncFileHandler from tempfile import NamedTemporaryFile from aiologger.handlers.base import Handler temp_file = NamedTemporaryFile() handler = AsyncFileHandler(filename=temp_file.name) class InterceptHandler(Handler): loglevel_mapping = { 50: 'CRITICAL', 40: 'ERROR', 30: 'WARNING', 20: 'INFO', 10: 'DEBUG', 0: 'NOTSET', } def emit(self, record): try: level = logger.level(record.levelname).name
import asyncio import json import time import discord import datetime from aiologger.loggers.json import JsonLogger from aiologger.handlers.files import AsyncFileHandler logger = JsonLogger() handler = AsyncFileHandler(filename="/tmp/message_dump.json") logger.add_handler(handler) def get_author(author): return ({ "id": author.id, "name": author.name, "discriminator": author.discriminator, "bot": author.bot, "icon_url": getattr(author, "icon_url", None), "guild": { "name": author.guild.name, "id": author.guild.id, } if getattr(author, "guild", None) else None, } if author else None) def get_field(field): return { "name": getattr(field, "name", None),
import logging from aiohttp import web from aiologger import Logger from aiologger.handlers.files import AsyncFileHandler formatter = logging.Formatter('%(asctime)s: %(levelname)s: %(message)s') logger = Logger.with_default_handlers(name='async-logger', level=logging.WARNING, formatter=formatter) file_handler = AsyncFileHandler(filename='log_data.log') logger.add_handler(file_handler) class ClientErrorHandler(web.HTTPException): @staticmethod async def not_found(req_text): # 404 return web.HTTPNotFound() @staticmethod async def bad_request(req_text): await logger.warning(f'Failed due to {req_text}') return web.HTTPBadRequest(reason=req_text) # 400 class ServerErrorsHandler(web.HTTPException): @staticmethod async def not_implemented(): # 501 return web.HTTPNotImplemented()