6848481318

Committed 13 Nov 2023 10:08AM UTC coverage: 86.696% (-2.4%) from 89.068%

Build # 6848481318

Build Type

push

github

Committed by

web-flow

Commit Message

feat: structlog integration (#122)

* feat: WIP structlog integration
* feat: add CI tests with structlog

---------

Signed-off-by: Michael Schilonka <michael@blueshoe.io>

Run Details

291 of 386 branches covered (0.0%)

Branch coverage included in aggregate %.

55 of 90 new or added lines in 5 files covered. (61.11%)

2 existing lines in 1 file now uncovered.

1299 of 1448 relevant lines covered (89.71%)

2.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.07

/hurricane/management/commands/serve.py

import asyncio
import functools
import os
import signal
import time
from concurrent.futures.thread import ThreadPoolExecutor

import tornado.autoreload
import tornado.web
import tornado.wsgi
from django.core.management.base import BaseCommand

from hurricane.management.commands import HURRICANE_DIST_VERSION
from hurricane.server import (
    check_db_and_migrations,
    command_task,
    logger,
    make_http_server_and_listen,
    make_probe_server,
    sanitize_probes,
    static_watch,
)
from hurricane.server.debugging import setup_debugging
from hurricane.server.loggers import STRUCTLOG_ENABLED

PROBE_CONFIGURED_EVENT = "Probe configured"
PROMETHEUS_CONFIGURED_EVENT = "Prometheus configured"


class Command(BaseCommand):

    """
    Start a Tornado-powered Django web server by using ``python manage.py serve <arguments>``.

    It can run Django management commands with the ``--command`` flag, that will be executed asynchronously.
    The application server will only be started upon successful execution of management commands. During execution
    of management commands the startup probe responds with a status 400.

    Arguments:
        - ``--static`` - serve collected static files
        - ``--media`` - serve media files
        - ``--autoreload`` - reload code on change
        - ``--debug`` - set Tornado's Debug flag
        - ``--port`` - the port for Tornado to listen on
        - ``--metrics`` - the exposed path (default is /metrics) to export Prometheus metrics
        - ``--startup-probe`` - the exposed path (default is /startup) for probes to check startup
        - ``--readiness-probe`` - the exposed path (default is /ready) for probes to check readiness
        - ``--liveness-probe`` - the exposed path (default is /alive) for probes to check liveness
        - ``--probe-port`` - the port for Tornado probe route to listen on
        - ``--req-queue-len`` - threshold of length of queue of request, which is considered for readiness probe
        - ``--no-probe`` - disable probe endpoint
        - ``--no-metrics`` - disable metrics collection
        - ``--command`` - repetitive command for adding execution of management commands before serving
        - ``--check-migrations`` - check if all migrations were applied before starting application
        - ``--check-migrations-apply`` - same as --check-migrations but also applies them if needed
        - ``--webhook-url``- If specified, webhooks will be sent to this url
        - ``--max-lifetime``- If specified,  maximum requests after which pod is restarted
        - ``--static-watch`` - If specified, static files will be watched for changes and recollected
    """

    help = "Start a Tornado-powered Django web server"

    def add_arguments(self, parser):
        """
        Defines arguments, that can be accepted with ``serve`` command.
        """
        parser.add_argument(
            "--static", action="store_true", help="Serve collected static files"
        )
        parser.add_argument("--media", action="store_true", help="Serve media files")
        parser.add_argument(
            "--autoreload", action="store_true", help="Reload code on change"
        )
        parser.add_argument(
            "--debug", action="store_true", help="Set Tornado's Debug flag"
        )
        parser.add_argument(
            "--port", type=int, default=8000, help="The port for Tornado to listen on"
        )
        parser.add_argument(
            "--metrics",
            type=str,
            dest="metrics_path",
            default="/metrics",
            help="The exposed path (default is /metrics) to export Prometheus metrics",
        )
        parser.add_argument(
            "--liveness-probe",
            type=str,
            default="/alive",
            help="The exposed path (default is /alive) for probes to check liveness",
        )
        parser.add_argument(
            "--readiness-probe",
            type=str,
            default="/ready",
            help="The exposed path (default is /ready) for probes to check readiness",
        )
        parser.add_argument(
            "--startup-probe",
            type=str,
            default="/startup",
            help="The exposed path (default is /startup) for probes to check startup",
        )
        parser.add_argument(
            "--probe-port",
            type=int,
            help="The port for Tornado probe route to listen on",
        )
        parser.add_argument(
            "--req-queue-len", type=int, default=10, help="Length of the request queue"
        )
        parser.add_argument(
            "--no-probe", action="store_true", help="Disable probe endpoint"
        )
        parser.add_argument(
            "--no-metrics", action="store_true", help="Disable metrics collection"
        )
        parser.add_argument("--command", type=str, action="append", nargs="+")
        parser.add_argument(
            "--check-migrations",
            action="store_true",
            help="Check if migrations were applied",
        )
        parser.add_argument(
            "--check-migrations-apply",
            action="store_true",
            help="Check if migrations were applied and apply them if needed",
        )
        parser.add_argument(
            "--debugger",
            action="store_true",
            help="Open a debugger port according to the Debug Adapter Protocol",
        )
        parser.add_argument(
            "--debugger-port",
            type=int,
            default=5678,
            help="The port for the debug client to attach",
        )
        parser.add_argument(
            "--webhook-url",
            type=str,
            help="Url for webhooks",
        )
        parser.add_argument(
            "--max-lifetime",
            type=int,
            default=None,
            help="Maximum requests after which pod is restarted",
        )
        parser.add_argument(
            "--static-watch",
            type=str,
            action="append",
            help="Watch files and run collectstatic if any file changed",
        )
        parser.add_argument(
            "--pycharm-host",
            type=str,
            default=None,
            help="The host of the pycharm debug server",
        )
        parser.add_argument(
            "--pycharm-port",
            type=int,
            default=None,
            help="The port of the pycharm debug server",
        )

    def handle(self, *args, **options):
        """
        Defines functionalities for different arguments. After all arguments were processed, it starts the async event
        loop.
        """
        start_time = time.time()
        if STRUCTLOG_ENABLED:
            logger.info(
                "Tornado-powered Django web server.",
                hurricane=HURRICANE_DIST_VERSION,
            )
        else:
            logger.info(
                f"Tornado-powered Django web server. Version: {HURRICANE_DIST_VERSION}"
            )

        if options["autoreload"]:
            tornado.autoreload.start()
            if options["static_watch"] and len(options["static_watch"]):
                logger.info("Watching static files for any changes")
                for path in options["static_watch"]:
                    if os.path.exists(path):
                        logger.info("Watching path {}.".format(path))
                        tornado.autoreload.watch(path)
                    else:
                        logger.error(
                            "Tried to watch {}, but it does not exist.".format(path)
                        )
                tornado.autoreload.add_reload_hook(static_watch)
            logger.info("Autoreload was performed")

        # set the probe port
        # the probe port by default is supposed to run the next port of the application
        probe_port = (
            options["probe_port"] if options["probe_port"] else options["port"] + 1
        )
        options["probe_port"] = probe_port

        # sanitize probes: returns regexps for probes in options and their representations for logging
        options, probe_representations = sanitize_probes(options)

        # set the probe routes
        # if probe port is set to the application's port, add it to the application's routes
        include_probe = False
        if not options["no_probe"]:
            if probe_port != options["port"]:
                if STRUCTLOG_ENABLED:
                    self.structlog_probe_configured(
                        probe_port, probe_representations, options
                    )
                else:
                    logger.info(
                        f"Starting probe application running on port {probe_port} with route liveness-probe: "
                        f"{probe_representations['liveness_probe']}, "
                        f"readiness-probe: {probe_representations['readiness_probe']}, "
                        f"startup-probe: {probe_representations['startup_probe']}"
                    )
                self.log_prometheus(options, probe_port)
                probe_application = make_probe_server(options, self.check)
                probe_application.listen(probe_port)
            else:
                include_probe = True
                if STRUCTLOG_ENABLED:
                    self.structlog_probe_configured(
                        probe_port, probe_representations, options
                    )
                else:
                    logger.info(
                        f"Starting probe application with routes "
                        f"liveness-probe: {probe_representations['liveness_probe']}, "
                        f"readiness-probe: {probe_representations['readiness_probe']}, "
                        f"startup-probe: {probe_representations['startup_probe']} "
                        f"running integrated on port {probe_port}"
                    )
                    self.log_prometheus(options, probe_port)

        else:
            if STRUCTLOG_ENABLED:
                logger.info("Probes configured", active=False)
                logger.info(PROMETHEUS_CONFIGURED_EVENT, active=False)
            else:
                logger.info("No probe application running")
                logger.info(
                    "Running without Prometheus exporter, because --no-probe flag was set"
                )
            options["no_metrics"] = True

        setup_debugging(options)

        loop = asyncio.get_event_loop()

        make_http_server_wrapper = functools.partial(
            make_http_server_and_listen,
            start_time=start_time,
            options=options,
            check=self.check,
            include_probe=include_probe,
        )

        # all commands, that should be executed before starting http server should be added to this list
        exec_list = []
        if options["command"]:
            # wrap function to use additional variables
            management_commands_wrapper = functools.partial(
                command_task,
                commands=options["command"],
                webhook_url=options["webhook_url"] or None,
                loop=loop,
            )
            exec_list.append(management_commands_wrapper)
        if options["check_migrations"] or options["check_migrations_apply"]:
            check_db_and_migrations_wrapper = functools.partial(
                check_db_and_migrations,
                webhook_url=options["webhook_url"] or None,
                loop=loop,
                apply_migration=True if options["check_migrations_apply"] else False,
            )
            exec_list.append(check_db_and_migrations_wrapper)

        def bundle_func(exec_list, loop, make_http_server_wrapper):
            # executes functions from exec_list sequentially
            for func in exec_list:
                func(*args)
            # after all functions were executed http server is started in the main thread
            # call_soon_threadsafe puts http server into the main loop of the program
            loop.call_soon_threadsafe(make_http_server_wrapper)

        executor = ThreadPoolExecutor(max_workers=1)
        # bundle_func is executed in a separate thread. Main thread has an active probe server, which should not be
        # interrupted
        loop.run_in_executor(
            executor, bundle_func, exec_list, loop, make_http_server_wrapper
        )

        def ask_exit(signame):
            logger.info(f"Received signal {signame}. Shutting down now.")
            loop.stop()

        for signame in ("SIGINT", "SIGTERM"):
            loop.add_signal_handler(
                getattr(signal, signame), functools.partial(ask_exit, signame)
            )

        loop.run_forever()

    def structlog_probe_configured(self, probe_port, probe_representations, options):
        logger.info(
            PROBE_CONFIGURED_EVENT,
            port=probe_port,
            active=True,
            liveness=probe_representations["liveness_probe"],
            readiness=probe_representations["readiness_probe"],
            startup=probe_representations["startup_probe"],
            integrated=probe_port == options["port"],
        )

    def log_prometheus(self, options, probe_port):
        if "no_metrics" not in options or not options["no_metrics"]:
            if STRUCTLOG_ENABLED:
                logger.info(
                    PROMETHEUS_CONFIGURED_EVENT,
                    port=probe_port,
                    route=options["metrics_path"],
                    active=True,
                )
            else:
                logger.info(
                    f"Starting Prometheus metrics exporter on port {probe_port} with "
                    f"route {options['metrics_path']}"
                )
        else:
            if STRUCTLOG_ENABLED:
                logger.info(PROMETHEUS_CONFIGURED_EVENT, active=False)
            else:
                logger.info(
                    "Running without Prometheus exporter, because --no-metrics flag was set"
                )

1	import asyncio	3✔
2	import functools	3✔
3	import os	3✔
4	import signal	3✔
5	import time	3✔
6	from concurrent.futures.thread import ThreadPoolExecutor	3✔
7
8	import tornado.autoreload	3✔
9	import tornado.web	3✔
10	import tornado.wsgi	3✔
11	from django.core.management.base import BaseCommand	3✔
12
13	from hurricane.management.commands import HURRICANE_DIST_VERSION	3✔
14	from hurricane.server import (	3✔
15	check_db_and_migrations,
16	command_task,
17	logger,
18	make_http_server_and_listen,
19	make_probe_server,
20	sanitize_probes,
21	static_watch,
22	)
23	from hurricane.server.debugging import setup_debugging	3✔
24	from hurricane.server.loggers import STRUCTLOG_ENABLED	3✔
25
26	PROBE_CONFIGURED_EVENT = "Probe configured"	3✔
27	PROMETHEUS_CONFIGURED_EVENT = "Prometheus configured"	3✔
28
29
30	class Command(BaseCommand):	3✔
31
32	"""
33	Start a Tornado-powered Django web server by using ``python manage.py serve <arguments>``.
34
35	It can run Django management commands with the ``--command`` flag, that will be executed asynchronously.
36	The application server will only be started upon successful execution of management commands. During execution
37	of management commands the startup probe responds with a status 400.
38
39	Arguments:
40	- ``--static`` - serve collected static files
41	- ``--media`` - serve media files
42	- ``--autoreload`` - reload code on change
43	- ``--debug`` - set Tornado's Debug flag
44	- ``--port`` - the port for Tornado to listen on
45	- ``--metrics`` - the exposed path (default is /metrics) to export Prometheus metrics
46	- ``--startup-probe`` - the exposed path (default is /startup) for probes to check startup
47	- ``--readiness-probe`` - the exposed path (default is /ready) for probes to check readiness
48	- ``--liveness-probe`` - the exposed path (default is /alive) for probes to check liveness
49	- ``--probe-port`` - the port for Tornado probe route to listen on
50	- ``--req-queue-len`` - threshold of length of queue of request, which is considered for readiness probe
51	- ``--no-probe`` - disable probe endpoint
52	- ``--no-metrics`` - disable metrics collection
53	- ``--command`` - repetitive command for adding execution of management commands before serving
54	- ``--check-migrations`` - check if all migrations were applied before starting application
55	- ``--check-migrations-apply`` - same as --check-migrations but also applies them if needed
56	- ``--webhook-url``- If specified, webhooks will be sent to this url
57	- ``--max-lifetime``- If specified, maximum requests after which pod is restarted
58	- ``--static-watch`` - If specified, static files will be watched for changes and recollected
59	"""
60
61	help = "Start a Tornado-powered Django web server"	3✔
62
63	def add_arguments(self, parser):	3✔
64	"""
65	Defines arguments, that can be accepted with ``serve`` command.
66	"""
67	parser.add_argument(	3✔
68	"--static", action="store_true", help="Serve collected static files"
69	)
70	parser.add_argument("--media", action="store_true", help="Serve media files")	3✔
71	parser.add_argument(	3✔
72	"--autoreload", action="store_true", help="Reload code on change"
73	)
74	parser.add_argument(	3✔
75	"--debug", action="store_true", help="Set Tornado's Debug flag"
76	)
77	parser.add_argument(	3✔
78	"--port", type=int, default=8000, help="The port for Tornado to listen on"
79	)
80	parser.add_argument(	3✔
81	"--metrics",
82	type=str,
83	dest="metrics_path",
84	default="/metrics",
85	help="The exposed path (default is /metrics) to export Prometheus metrics",
86	)
87	parser.add_argument(	3✔
88	"--liveness-probe",
89	type=str,
90	default="/alive",
91	help="The exposed path (default is /alive) for probes to check liveness",
92	)
93	parser.add_argument(	3✔
94	"--readiness-probe",
95	type=str,
96	default="/ready",
97	help="The exposed path (default is /ready) for probes to check readiness",
98	)
99	parser.add_argument(	3✔
100	"--startup-probe",
101	type=str,
102	default="/startup",
103	help="The exposed path (default is /startup) for probes to check startup",
104	)
105	parser.add_argument(	3✔
106	"--probe-port",
107	type=int,
108	help="The port for Tornado probe route to listen on",
109	)
110	parser.add_argument(	3✔
111	"--req-queue-len", type=int, default=10, help="Length of the request queue"
112	)
113	parser.add_argument(	3✔
114	"--no-probe", action="store_true", help="Disable probe endpoint"
115	)
116	parser.add_argument(	3✔
117	"--no-metrics", action="store_true", help="Disable metrics collection"
118	)
119	parser.add_argument("--command", type=str, action="append", nargs="+")	3✔
120	parser.add_argument(	3✔
121	"--check-migrations",
122	action="store_true",
123	help="Check if migrations were applied",
124	)
125	parser.add_argument(	3✔
126	"--check-migrations-apply",
127	action="store_true",
128	help="Check if migrations were applied and apply them if needed",
129	)
130	parser.add_argument(	3✔
131	"--debugger",
132	action="store_true",
133	help="Open a debugger port according to the Debug Adapter Protocol",
134	)
135	parser.add_argument(	3✔
136	"--debugger-port",
137	type=int,
138	default=5678,
139	help="The port for the debug client to attach",
140	)
141	parser.add_argument(	3✔
142	"--webhook-url",
143	type=str,
144	help="Url for webhooks",
145	)
146	parser.add_argument(	3✔
147	"--max-lifetime",
148	type=int,
149	default=None,
150	help="Maximum requests after which pod is restarted",
151	)
152	parser.add_argument(	3✔
153	"--static-watch",
154	type=str,
155	action="append",
156	help="Watch files and run collectstatic if any file changed",
157	)
158	parser.add_argument(	3✔
159	"--pycharm-host",
160	type=str,
161	default=None,
162	help="The host of the pycharm debug server",
163	)
164	parser.add_argument(	3✔
165	"--pycharm-port",
166	type=int,
167	default=None,
168	help="The port of the pycharm debug server",
169	)
170
171	def handle(self, args, *options):	3✔
172	"""
173	Defines functionalities for different arguments. After all arguments were processed, it starts the async event
174	loop.
175	"""
176	start_time = time.time()	3✔
177	if STRUCTLOG_ENABLED:	3!
NEW 178	logger.info(	×
179	"Tornado-powered Django web server.",
180	hurricane=HURRICANE_DIST_VERSION,
181	)
182	else:
183	logger.info(	3✔
184	f"Tornado-powered Django web server. Version: {HURRICANE_DIST_VERSION}"
185	)
186
187	if options["autoreload"]:	3✔
188	tornado.autoreload.start()	3✔
189	if options["static_watch"] and len(options["static_watch"]):	3✔
190	logger.info("Watching static files for any changes")	3✔
191	for path in options["static_watch"]:	3✔
192	if os.path.exists(path):	3✔
193	logger.info("Watching path {}.".format(path))	3✔
194	tornado.autoreload.watch(path)	3✔
195	else:
196	logger.error(	3✔
197	"Tried to watch {}, but it does not exist.".format(path)
198	)
199	tornado.autoreload.add_reload_hook(static_watch)	3✔
200	logger.info("Autoreload was performed")	3✔
201
202	# set the probe port
203	# the probe port by default is supposed to run the next port of the application
204	probe_port = (	3✔
205	options["probe_port"] if options["probe_port"] else options["port"] + 1
206	)
207	options["probe_port"] = probe_port	3✔
208
209	# sanitize probes: returns regexps for probes in options and their representations for logging
210	options, probe_representations = sanitize_probes(options)	3✔
211
212	# set the probe routes
213	# if probe port is set to the application's port, add it to the application's routes
214	include_probe = False	3✔
215	if not options["no_probe"]:	3✔
216	if probe_port != options["port"]:	3✔
217	if STRUCTLOG_ENABLED:	3!
NEW 218	self.structlog_probe_configured(	×
219	probe_port, probe_representations, options
220	)
221	else:
222	logger.info(	3✔
223	f"Starting probe application running on port {probe_port} with route liveness-probe: "
224	f"{probe_representations['liveness_probe']}, "
225	f"readiness-probe: {probe_representations['readiness_probe']}, "
226	f"startup-probe: {probe_representations['startup_probe']}"
227	)
228	self.log_prometheus(options, probe_port)	3✔
229	probe_application = make_probe_server(options, self.check)	3✔
230	probe_application.listen(probe_port)	3✔
231	else:
232	include_probe = True	3✔
233	if STRUCTLOG_ENABLED:	3!
NEW 234	self.structlog_probe_configured(	×
235	probe_port, probe_representations, options
236	)
237	else:
238	logger.info(	3✔
239	f"Starting probe application with routes "
240	f"liveness-probe: {probe_representations['liveness_probe']}, "
241	f"readiness-probe: {probe_representations['readiness_probe']}, "
242	f"startup-probe: {probe_representations['startup_probe']} "
243	f"running integrated on port {probe_port}"
244	)
245	self.log_prometheus(options, probe_port)	3✔
246
247	else:
248	if STRUCTLOG_ENABLED:	3!
NEW 249	logger.info("Probes configured", active=False)	×
NEW 250	logger.info(PROMETHEUS_CONFIGURED_EVENT, active=False)	×
251	else:
252	logger.info("No probe application running")	3✔
253	logger.info(	3✔
254	"Running without Prometheus exporter, because --no-probe flag was set"
255	)
256	options["no_metrics"] = True	3✔
257
258	setup_debugging(options)	3✔
259
260	loop = asyncio.get_event_loop()	3✔
261
262	make_http_server_wrapper = functools.partial(	3✔
263	make_http_server_and_listen,
264	start_time=start_time,
265	options=options,
266	check=self.check,
267	include_probe=include_probe,
268	)
269
270	# all commands, that should be executed before starting http server should be added to this list
271	exec_list = []	3✔
272	if options["command"]:	3✔
273	# wrap function to use additional variables
274	management_commands_wrapper = functools.partial(	3✔
275	command_task,
276	commands=options["command"],
277	webhook_url=options["webhook_url"] or None,
278	loop=loop,
279	)
280	exec_list.append(management_commands_wrapper)	3✔
281	if options["check_migrations"] or options["check_migrations_apply"]:	3✔
282	check_db_and_migrations_wrapper = functools.partial(	3✔
283	check_db_and_migrations,
284	webhook_url=options["webhook_url"] or None,
285	loop=loop,
286	apply_migration=True if options["check_migrations_apply"] else False,
287	)
288	exec_list.append(check_db_and_migrations_wrapper)	3✔
289
290	def bundle_func(exec_list, loop, make_http_server_wrapper):	3✔
291	# executes functions from exec_list sequentially
292	for func in exec_list:	×
293	func(*args)	×
294	# after all functions were executed http server is started in the main thread
295	# call_soon_threadsafe puts http server into the main loop of the program
296	loop.call_soon_threadsafe(make_http_server_wrapper)	×
297
298	executor = ThreadPoolExecutor(max_workers=1)	3✔
299	# bundle_func is executed in a separate thread. Main thread has an active probe server, which should not be
300	# interrupted
301	loop.run_in_executor(	3✔
302	executor, bundle_func, exec_list, loop, make_http_server_wrapper
303	)
304
305	def ask_exit(signame):	3✔
306	logger.info(f"Received signal {signame}. Shutting down now.")	3✔
307	loop.stop()	3✔
308
309	for signame in ("SIGINT", "SIGTERM"):	3✔
310	loop.add_signal_handler(	3✔
311	getattr(signal, signame), functools.partial(ask_exit, signame)
312	)
313
314	loop.run_forever()	3✔
315
316	def structlog_probe_configured(self, probe_port, probe_representations, options):	3✔
NEW 317	logger.info(	×
318	PROBE_CONFIGURED_EVENT,
319	port=probe_port,
320	active=True,
321	liveness=probe_representations["liveness_probe"],
322	readiness=probe_representations["readiness_probe"],
323	startup=probe_representations["startup_probe"],
324	integrated=probe_port == options["port"],
325	)
326
327	def log_prometheus(self, options, probe_port):	3✔
328	if "no_metrics" not in options or not options["no_metrics"]:	3✔
329	if STRUCTLOG_ENABLED:	3!
NEW 330	logger.info(	×
331	PROMETHEUS_CONFIGURED_EVENT,
332	port=probe_port,
333	route=options["metrics_path"],
334	active=True,
335	)
336	else:
337	logger.info(	3✔
338	f"Starting Prometheus metrics exporter on port {probe_port} with "
339	f"route {options['metrics_path']}"
340	)
341	else:
342	if STRUCTLOG_ENABLED:	3!
NEW 343	logger.info(PROMETHEUS_CONFIGURED_EVENT, active=False)	×
344	else:
345	logger.info(	3✔
346	"Running without Prometheus exporter, because --no-metrics flag was set"
347	)

django-hurricane / django-hurricane / 6848481318

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous