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()
