def main(): args = parser.parse_args() clear_environ(lambda i: i.startswith(ENV_VAR_PREFIX)) # Чтобы логи не блокировали основной поток (и event loop) во время операций # записи в stderr или файл - логи можно буфферизовать и обрабатывать в # отдельном потоке (aiomisc.basic_config настроит буфферизацию # автоматически). basic_config(args.log_level, args.log_format, buffered=True) # Аллоцируем сокет из под привиллегированного пользователя отдельным шагом, # чтобы была возможность перед запуском приложения сменить пользователя ОС. sock = bind_socket( address=args.api_address, port=args.api_port, proto_name='http', ) # После того как приложение аллоцировало сокет и ему больше не нужны # привиллегии - хорошим решением будет сменить пользователя (например, # на nobody, у которого нет никаких специальных привиллегий) - это также # усложнит жизнь злоумышленникам. if args.user is not None: logging.info('Changing user to %r', args.user.pw_name) os.setgid(args.user.pw_gid) os.setuid(args.user.pw_uid) # В списке процессов намного удобнее видеть название текущего приложения setproctitle(os.path.basename(argv[0])) app = create_app(args) run_app(app, sock=sock)
def init_app(sub_apps: Dict[str, web.Application] = None): """ Main init routine. :param sub_apps: the dictionary contains prefix: sub_app that should be appended to the main app :return: """ args = get_args() app = web.Application() app["args"] = args basic_config(level=log_level(args.log_level)) if sub_apps: for prefix, sub_app in sub_apps.items(): app.add_subapp(prefix, sub_app) app.add_routes([ web.get("/status", routes.status), web.get("/tasks", routes.task_list), web.post("/add_task", routes.add_task), ]) for st, cl in zip_longest(connection_routine.startup_callbacks, connection_routine.cleanup_callbacks): if st: app.on_startup.append(st) if cl: app.on_cleanup.append(cl) return app
def main(): global STORAGE arguments = parser.parse_args() basic_config(level=arguments.log_level, log_format=arguments.log_format, buffered=False) setproctitle(os.path.basename("[Master] %s" % sys.argv[0])) tcp_sock = bind_socket(address=arguments.tcp_listen, port=arguments.tcp_port) pickle_sock = bind_socket(address=arguments.pickle_listen, port=arguments.pickle_port) udp_sock = bind_socket( socket.AF_INET6 if ':' in arguments.udp_listen else socket.AF_INET, socket.SOCK_DGRAM, address=arguments.udp_listen, port=arguments.udp_port) test_path = os.path.join(arguments.storage, '.test') with open(test_path, 'ab+') as fp: assert fp.truncate(0) == 0, ("Truncating not supported on %r" % arguments.storage) forkme.fork(arguments.forks) setproctitle(os.path.basename("[Worker] %s" % sys.argv[0])) loop = new_event_loop(arguments.pool_size) loop.set_debug(arguments.debug) basic_config(level=arguments.log_level, log_format=arguments.log_format, buffered=True, loop=loop) loop.create_task(amain(loop, tcp_sock, pickle_sock, udp_sock)) loop.create_task( sender(arguments.carbon_proxy_url, arguments.carbon_proxy_secret)) STORAGE = Storage(os.path.join(arguments.storage, "%03d.bin" % (forkme.get_id() or 0)), loop=loop) try: loop.run_forever() finally: loop.stop() loop.run_until_complete(loop.shutdown_asyncgens())
def main(): args = read_args_from_env().parse_args() basic_config(args.log_level, args.log_format) if args.user is not None: logging.info('Changing user to %r', args.user.pw_name) os.setgid(args.user.pw_gid) os.setuid(args.user.pw_uid) app = create_app() web.run_app(app, host=args.http_address, port=args.http_port)
def test_configure_logging_json(capsys): data = str(uuid.uuid4()) basic_config(level=logging.DEBUG, log_format='json', buffered=False) logging.info(data) time.sleep(0.3) stdout, stderr = capsys.readouterr() json_result = json.loads(stdout.strip()) assert json_result['msg'] == data logging.basicConfig(handlers=[], level=logging.INFO)
def main(): arguments = parser.parse_args() basic_config(level=arguments.log_level, log_format=arguments.log_format, buffered=False) setproctitle(os.path.basename("[Master] %s" % sys.argv[0])) tcp_sock = bind_socket(address=arguments.tcp_listen, port=arguments.tcp_port) pickle_sock = bind_socket(address=arguments.pickle_listen, port=arguments.pickle_port) udp_sock = bind_socket( socket.AF_INET6 if ':' in arguments.udp_listen else socket.AF_INET, socket.SOCK_DGRAM, address=arguments.udp_listen, port=arguments.udp_port) def run(): setproctitle(os.path.basename("[Worker] %s" % sys.argv[0])) storage = Storage( os.path.join(arguments.storage, "%03d.db" % forklib.get_id())) services = [ CarbonTCPServer(sock=tcp_sock, storage=storage), CarbonPickleServer(sock=pickle_sock, storage=storage), CarbonUDPServer(sock=udp_sock, storage=storage), SenderService( proxy_url=arguments.carbon_proxy_url, secret=arguments.carbon_proxy_secret, storage=storage, interval=arguments.sender_interval, chunk_size=arguments.chunk_size, ) ] with entrypoint(*services, log_level=arguments.log_level, log_format=arguments.log_format, pool_size=arguments.pool_size) as loop: loop.set_debug(arguments.debug) loop.run_forever() if arguments.debug: run() else: forklib.fork(arguments.forks, run)
def main(): arguments = parser.parse_args() os.environ.clear() basic_config( level=arguments.log_level, log_format=arguments.log_format, buffered=False, ) setproctitle(os.path.basename("[Master] %s" % sys.argv[0])) sock = bind_socket(address=arguments.http_address, port=arguments.http_port) queue = deque() services = [ API( sock=sock, password=arguments.http_password, login=arguments.http_login, queue=queue, ), Sender( jaeger_route=arguments.jaeger_route, interval=arguments.sender_interval, queue=queue, ), ] if arguments.user is not None: logging.info("Changing user to %r", arguments.user.pw_name) os.setgid(arguments.user.pw_gid) os.setuid(arguments.user.pw_uid) def run(): setproctitle(os.path.basename("[Worker] %s" % sys.argv[0])) with entrypoint(*services, pool_size=arguments.pool_size, log_level=arguments.log_level, log_format=arguments.log_format, debug=arguments.debug) as loop: loop.run_forever() if arguments.forks: forklib.fork(arguments.forks, run, auto_restart=True) else: run()
def test_configure_logging_stderr(capsys): data = str(uuid.uuid4()) out, err = capsys.readouterr() # logging.basicConfig(level=logging.INFO) basic_config(level=logging.DEBUG, log_format='stream', buffered=False) logging.info(data) time.sleep(0.3) stdout, stderr = capsys.readouterr() assert data in stderr logging.basicConfig(handlers=[])
def main(): args = parser.parse_args() config = load_config(args.config) setproctitle(config["settings"]["proc_title"]) basic_config(level=config["settings"]["log_level"], log_format='color', flush_interval=2) service = APIService(address=config["server"]["host"], port=config["server"]["port"], config=config) with entrypoint(service) as loop: loop.run_forever()
async def init_app(arguments: Namespace = None) -> web.Application: args = arguments or get_args() middlewares = [jwt_authorization] if not args.debug_token else list() app = web.Application(middlewares=middlewares) app["args"] = args app["broker"] = RabbitClient(connection_string=args.amqp_connection, robust=False, pool=False, ssl_options=ssl_options(), exchange_name=AMQP_SETTINGS.get("topic_exchange_name"), exchange_type=AMQP_SETTINGS.get("exchange_type")) app["sessions"] = weakref.WeakSet() basic_config(level=log_level(args.log_level)) app.add_routes([ web.get("/ws", ws_handler) ]) app.on_startup.append(init_services) app.on_cleanup.append(cleanup) return app
def main(): args = parser.parse_args() sentry_sdk.init(dsn=args.sentry_dsn, environment=args.sentry_environment, integrations=[AioHttpIntegration()]) # Clear env variables of the app after start for security reasons. # Clear variables that starts with ENV_VAR_PREFIX. clear_environ(lambda i: i.startswith(ENV_VAR_PREFIX)) # For processing logs in a separate thread. basic_config(args.log_level, args.log_format, buffered=True) setproctitle(os.path.basename(argv[0])) app = create_app() run_app(app, host=args.api_address, port=args.api_port)
def main(): global SECRET arguments = parser.parse_args() os.environ.clear() basic_config(level=arguments.log_level, log_format=arguments.log_format, buffered=False) setproctitle(os.path.basename("[Master] %s" % sys.argv[0])) sock = bind_socket(address=arguments.http_address, port=arguments.http_port) services = [ API( secret=arguments.http_secret, sock=sock, ), Sender( routes=arguments.routes, interval=arguments.sender_interval, ) ] if arguments.user is not None: logging.info('Changing user to %r', arguments.user.pw_name) os.setgid(arguments.user.pw_gid) os.setuid(arguments.user.pw_uid) def run(): setproctitle(os.path.basename("[Worker] %s" % sys.argv[0])) with entrypoint(*services, pool_size=arguments.pool_size, log_level=arguments.log_level, log_format=arguments.log_format) as loop: loop.set_debug(arguments.debug) loop.run_forever() if arguments.forks: forklib.fork(arguments.forks, run, auto_restart=True) else: run()
def main(): args = parser.parse_args() clear_environ(lambda i: i.startswith(ENV_VAR_PREFIX)) basic_config(args.log_level, args.log_format, buffered=True) train, test, item_features, item_feature_labels = fetch_dataset() engine = create_engine(str(args.pg_url)) try: with engine.begin() as conn: fill_users_table(conn, train) fill_items_table(conn, train) fill_interactions_table(conn, train) fill_interactions_table(conn, test) fill_item_features_table(conn, item_features, item_feature_labels) fill_item_descriptions_table(conn, item_features) finally: engine.dispose()
def main(): args = parser.parse_args() clear_environ(lambda i: i.startswith(ENV_VAR_PREFIX)) basic_config(args.log_level, args.log_format, buffered=True) sock = bind_socket(address=args.api_address, port=args.api_port, proto_name='http') if args.user is not None: logging.info('Changing user to %r', args.user.pw_name) os.setgid(args.user.pw_gid) os.setuid(args.user.pw_uid) setproctitle(os.path.basename(argv[0])) app = create_app(args) run_app(app, sock=sock)
def main(): args = parser.parse_args() clear_environ(lambda i: i.startswith(ENV_VAR_PREFIX)) basic_config(args.log_level, args.log_format, buffered=True) # engine = create_engine(args.pg_url) # try: # with engine.begin() as conn: users = fetch_active_users() items = fetch_latest_items() train, test, user_features, item_features = fetch_training_data() # finally: # engine.dispose() model = train_model(train, test, user_features, item_features) predictions = predict(model, users, items, user_features, item_features) with Redis.from_url(str(args.redis_url)) as r: cache_predictions(r, predictions, args.redis_ttl) cache_latest_items(r, items[:100], args.redis_ttl)
def main(): global SECRET arguments = parser.parse_args() basic_config(level=arguments.log_level, log_format=arguments.log_format, buffered=False) setproctitle(os.path.basename("[Master] %s" % sys.argv[0])) sock = bind_socket(address=arguments.http_address, port=arguments.http_port) forkme.fork(arguments.forks) setproctitle(os.path.basename("[Worker] %s" % sys.argv[0])) SECRET = arguments.http_secret loop = new_event_loop(arguments.pool_size) loop.set_debug(arguments.debug) app = make_app(arguments) app._debug = arguments.debug app.on_startup.append(setup_routes) app.on_startup.append(partial(setup_sender, arguments=arguments)) log.info("Starting application http://%s:%d", arguments.http_address, arguments.http_port) basic_config(level=arguments.log_level, log_format=arguments.log_format, buffered=True, loop=loop) try: run_app(sock=sock, loop=loop, app=app, print=log.debug) except GracefulExit: log.info("Exiting")
def main(): args = parser.parse_args() # После получения конфигурации приложения переменные окружения приложения # больше не нужны и даже могут представлять опасность - например, они могут # случайно "утечь" с отображением информации об ошибке. Злоумышленники # в первую очередь будут пытаться получить информацию об окружении, очистка # переменных окружения считается хорошим тоном. # Python позволяет управлять поведением stdlib модулей с помощью # многочисленных переменных окружения, разумно очищать переменные окружения # по префиксу приложения, указанного в ConfigArgParser. clear_environ(lambda i: i.startswith(ENV_VAR_PREFIX)) # Чтобы логи не блокировали основной поток (и event loop) во время операций # записи в stderr или файл - логи можно буфферизовать и обрабатывать в # отдельном потоке (aiomisc.basic_config настроит буфферизацию # автоматически). basic_config(args.log_level, args.log_format, buffered=True) # Аллоцируем сокет из под привиллегированного пользователя отдельным шагом, # чтобы была возможность перед запуском приложения сменить пользователя ОС. sock = bind_socket(address=args.api_address, port=args.api_port, proto_name='http') # После того как приложение аллоцировало сокет и ему больше не нужны # привиллегии - хорошим решением будет сменить пользователя (например, # на nobody, у которого нет никаких специальных привиллегий) - это также # усложнит жизнь злоумышленникам. if args.user is not None: logging.info('Changing user to %r', args.user.pw_name) os.setgid(args.user.pw_gid) os.setuid(args.user.pw_uid) # В списке процессов намного удобнее видеть название текущего приложения setproctitle(os.path.basename(argv[0])) app = create_app(args) run_app(app, sock=sock)
def main(): from aiomisc.log import basic_config debug = True basic_config(logging.DEBUG, buffered=True) loop = asyncio.get_event_loop() # logging.basicConfig(level=logging.DEBUG if debug else logging.INFO) reload = False while True: bot_loop_task = asyncio.ensure_future(bot_loop()) try: if reload: loop.run_until_complete( run_with_reloader(loop, bot_loop_task, bot.stop)) else: loop.run_until_complete(bot_loop_task) # User cancels except KeyboardInterrupt: logger.debug("User cancelled") bot_loop_task.cancel() bot.stop() break # Stop loop finally: if AIOHTTP_23: loop.run_until_complete(bot.session.close()) logger.debug("Closing loop") loop.stop() loop.close()
def main(): args = parser.parse_args() # После получения конфигурации приложения переменные окружения приложения # больше не нужны и даже могут представлять опасность - например, они могут # случайно "утечь" с отображением информации об ошибке. Злоумышленники # в первую очередь будут пытаться получить информацию об окружении, очистка # переменных окружения считается хорошим тоном. # Python позволяет управлять поведением stdlib модулей с помощью # многочисленных переменных окружения, разумно очищать переменные окружения # по префиксу приложения, указанного в ConfigArgParser. clean_environ(rule=lambda var: var.startswith(ENV_VAR_PREFIX)) # Чтобы логи не блокировали основной поток (и event loop) во время операций # записи в stderr или файл - логи можно буфферизовать и обрабатывать в # отдельном потоке (aiomisc.basic_config настроит буфферизацию # автоматически). basic_config(level=args.log_level, log_format=args.log_format, buffered=True) app = create_app(args=args) web.run_app(app=app, host=args.api_address, port=args.api_port)
from config import AppConfig import logging from aiomisc.log import basic_config from aiohttp.web import Application basic_config(AppConfig.LOGGING, buffered=True) logger = logging.getLogger("api_logger") host = AppConfig.HOST port = AppConfig.PORT app = Application(client_max_size=AppConfig.MAX_REQUEST_SIZE)
def main() -> None: address: Union[str, Tuple[str, int]] cookie: bytes identity: str (address, cookie, identity, log_level, log_format) = pickle.load(sys.stdin.buffer) basic_config(level=log_level, log_format=log_format) family = (socket.AF_UNIX if isinstance(address, str) else INET_AF) with socket.socket(family, socket.SOCK_STREAM) as sock: logging.debug("Connecting...") sock.connect(address) def send(packet_type: PacketTypes, data: Any) -> None: payload = pickle.dumps(data) sock.send(Header.pack(packet_type.value, len(payload))) sock.send(payload) def receive() -> Tuple[PacketTypes, Any]: header = sock.recv(Header.size) if not header: raise ValueError("No data") packet_type, payload_length = Header.unpack(header) payload = sock.recv(payload_length) return PacketTypes(packet_type), pickle.loads(payload) def auth(cookie: bytes) -> None: hasher = HASHER() salt = urandom(SALT_SIZE) send(PacketTypes.AUTH_SALT, salt) hasher.update(salt) hasher.update(cookie) send(PacketTypes.AUTH_DIGEST, hasher.digest()) packet_type, value = receive() if packet_type == PacketTypes.AUTH_OK: return value raise RuntimeError(PacketTypes(packet_type), value) def step() -> bool: try: packet_type, (func, args, kwargs) = receive() except ValueError: return True if packet_type == packet_type.REQUEST: response_type = PacketTypes.RESULT try: result = func(*args, **kwargs) except Exception as e: response_type = PacketTypes.EXCEPTION result = e logging.exception("Exception when processing request") send(response_type, result) return False logging.debug("Starting authorization") auth(cookie) del cookie send(PacketTypes.IDENTITY, identity) logging.debug("Worker ready") try: while not step(): pass except KeyboardInterrupt: return
import os import asyncio import aiohttp from aiohttp import web import socket import logging import json from motor.motor_asyncio import AsyncIOMotorClient from bson import json_util from aiomisc.log import LogFormat, LogLevel, basic_config basic_config(LogLevel.info, LogFormat.color, buffered=True) log = logging.getLogger(__name__) class WebSocketHandler: def __init__(self, url: str, db_client, loop=None) -> None: self.url = url self.loop = loop or asyncio.get_event_loop() self.session = None self.websocket = None self.client = db_client self.db = self.client.get_database() async def connect(self): conn = aiohttp.TCPConnector( family=socket.AF_INET, ssl=False, ) self.session = aiohttp.ClientSession(loop=self.loop,
import asyncio import logging from aiohttp import web from aiomisc.service.aiohttp import AIOHTTPService from aiomisc import entrypoint from aiomisc.log import basic_config from routes import setup_routes from views import update_rate log = logging.getLogger(__name__) basic_config( level=logging.INFO, log_format='color', buffered=False, buffer_size=1024, ) async def start_background_tasks(app): app['rate_updater'] = asyncio.create_task(update_rate(app)) log.info("Background task are created") async def cleanup_background_tasks(app): app['rate_updater'].cancel() log.info("Background task are cancelled") await app['rate_updater']
from aiomisc.log import basic_config import logging from .app import run_services basic_config(level=logging.INFO, buffered=True, log_format='color') name = 'exchanges_rates_async'
import logging from aiomisc.log import basic_config basic_config(level=logging.INFO, buffered=False, log_format='json') log = logging.getLogger('service')