It can be useful to measure the execution time of functions to ensure your code is running well. An execution time way longer than average implies an issue. Here is a lightweight context manager, implemented as a decorator, which saves some metrics on your functions' runtime.
This simple Metric class gets implemented as a context manager, and saves the function name and execution time. All it requires is a database connection to save the metrics.
from contextlib import ContextDecorator,contextmanager
import pymysql.cursors
from time import time
class DatabaseFactory():
def __init__(self, host: str, user: str, password: str, database: str, port: int):
self.host: str = host
self.user: str = user
self.password = password
self.database: str = database
self.port: int = port
@contextmanager
def connection(self):
connection = self._connect()
try:
yield connection
except Exception as ex:
raise ex
finally:
connection.close()
def _connect(self):
return pymysql.connect(
host=self.host,
user=self.user,
password=self.password,
db=self.database,
charset="utf8mb4",
cursorclass=pymysql.cursors.DictCursor,
autocommit=True,
port=self.port,
)
db = DatabaseFactory(
host="127.0.0.1",
user="root",
password="",
database="metric",
port=3306,
)
class Metric():
def __init__(self, function: object):
self.function: object = function
def __call__(self):
t_start = time()
self.function()
t_end = time()
self._metrics(self.function.__name__, t_end-t_start)
def _metrics(self, function_name: str, execution_time: float):
with db.connection() as connection:
with connection.cursor() as curs:
curs.execute("INSERT INTO metrics (function_name, execution_time) VALUES (%s, %s)", (function_name, execution_time*1000000))
Most of the lines are dedicated to opening up a MySQL database connection and using a MySQL database called metric.
The class Metric will get implemented as a decorator and just invokes the function and saves the function name and execution time (in ms) into the database.
To implement this class as a decorator, all I need is the following small function.
from metric import Metric
import time
@Metric
def test():
time.sleep(5)
Now every time the test function gets run I should see a new entry in my table. This is what it looks like:
select * from metrics;
+----+---------------+----------------+
| id | function_name | execution_time |
+----+---------------+----------------+
| 1 | test | 5005049 |
+----+---------------+----------------+
1 row in set (0.01 sec)
Perfect! Though this is only one metric, there are a whole host of other useful metrics to track - the sky is the limit.