WIP

Author: Patrick Vogel

.github/workflows/python-publish.yml

@@ -1,8 +1,10 @@
 name: Upload Python Package
 
 on:
-  release:
-    types: [created]
+  push:
+    branches:
+      - master
+      - development
 
 jobs:
   deploy:

.github/workflows/python-test.yml

@@ -22,12 +22,10 @@ jobs:
         pip install -r requirements-dev.txt
     - name: Lint with flake8
       run: |
-        pip install flake8
         flake8 . --exit-zero --max-line-length=100 --ignore=F401,W503 --max-complexity=10 --max-line-length=100
-    - name: Test with unittest
+    - name: Test with pytest
       run: |
-        coverage run setup.py test
-        coverage xml
+        pytest --cov --cov-report=xml
     - name: Upload coverage to Codecov
       uses: codecov/codecov-action@v1
       with:

MANIFEST.in

@@ -1,6 +1,5 @@
 recursive-include flask_monitoringdashboard/static *
 recursive-include flask_monitoringdashboard/templates *
-recursive-include flask_monitoringdashboard/test *
 include requirements.txt
 include README.md
 include docs/changelog.rst

flask_monitoringdashboard/__init__.py

@@ -1,15 +1,15 @@
-"""
-    The app tracks the performance of various endpoints over time.
-    To bind, use the following lines of code:
-        import dashboard
-        from flask import Flask
-        ...
-        app = Flask(__name__)
-        ...
-        dashboard.bind(app)
-
-    The dashboard with the results that are collected can be found at:
-        localhost:5000/dashboard
+"""The app tracks the performance of various endpoints over time.
+To bind, use the following lines of code:
+
+>>> import flask_monitoringdashboard as dashboard
+>>> from flask import Flask
+    ...
+>>> app = Flask(__name__)
+    ...
+>>> dashboard.bind(app)
+
+The dashboard with the results that are collected can be found at:
+    localhost:5000/dashboard
 """
 
 import os
@@ -22,21 +22,21 @@
 config = Config()
 
 
-# get current location of the project
 def loc():
+    """Get the current location of the project."""
     return os.path.abspath(os.path.dirname(__file__)) + '/'
 
 
-# define the blueprint
 blueprint = Blueprint('dashboard', __name__, template_folder=loc() + 'templates')
+"""Define the blueprint."""
 
 
 def bind(app, schedule=True):
-    """
-        Binding the app to this object should happen before importing the routing-
-        methods below. Thus, the importing statement is part of this function.
-        :param app: the app for which the performance has to be tracked
-        :param schedule: flag telling if the background scheduler should be started
+    """Binding the app to this object should happen before importing the routing-
+    methods below. Thus, the importing statement is part of this function.
+
+    :param app: the app for which the performance has to be tracked
+    :param schedule: flag telling if the background scheduler should be started
     """
     config.app = app
     # Provide a secret-key for using WTF-forms
@@ -79,8 +79,8 @@ def bind(app, schedule=True):
 
 
 def add_graph(title, func, trigger="interval", **schedule):
-    """
-    Add a custom graph to the dashboard. You must specify the following arguments
+    """Add a custom graph to the dashboard. You must specify the following arguments:
+
     :param title: title of the graph (must be unique)
     :param schedule: dict containing values for weeks, days, hours, minutes, seconds
     :param func: function reference without arguments

flask_monitoringdashboard/cli.py

@@ -1,7 +1,7 @@
-"""
-Contains custom commands for the Flask-MonitoringDashboard
+"""Contains custom commands for the Flask-MonitoringDashboard
 For a list of all commands, open a terminal and type:
-    flask fmd --help
+
+>>> flask fmd --help
 """
 
 import click

flask_monitoringdashboard/controllers/__init__.py

@@ -1,3 +1 @@
-"""
-This directory is used for implementing the logic between the database and the API
-"""
+"""This directory is used for implementing the logic between the database and the API."""

flask_monitoringdashboard/controllers/endpoints.py

@@ -1,9 +1,10 @@
 import datetime
 
 from numpy import median
+from sqlalchemy import and_
 
-import flask_monitoringdashboard.core.cache as cache
 from flask_monitoringdashboard import config
+from flask_monitoringdashboard.core import cache
 from flask_monitoringdashboard.core.colors import get_color
 from flask_monitoringdashboard.core.measurement import add_decorator
 from flask_monitoringdashboard.core.timezone import to_local_datetime, to_utc_datetime
@@ -22,12 +23,11 @@
     update_endpoint,
 )
 from flask_monitoringdashboard.database.versions import get_first_requests
-from sqlalchemy import and_
 
 
-def get_endpoint_overview(db_session):
+def get_endpoint_overview(session):
     """
-    :param db_session: session for the database
+    :param session: session for the database
     :return: A list of properties for each endpoint that is found in the database
     """
     week_ago = datetime.datetime.utcnow() - datetime.timedelta(days=7)
@@ -39,22 +39,22 @@ def get_endpoint_overview(db_session):
     cache.flush_cache()
     error_hits_criterion = and_(Request.status_code >= 400, Request.status_code < 600)
 
-    hits_today = count_requests_group(db_session, Request.time_requested > today_utc)
+    hits_today = count_requests_group(session, Request.time_requested > today_utc)
     hits_today_errors = count_requests_group(
-        db_session, and_(Request.time_requested > today_utc, error_hits_criterion)
+        session, and_(Request.time_requested > today_utc, error_hits_criterion)
     )
 
-    hits_week = count_requests_group(db_session, Request.time_requested > week_ago)
+    hits_week = count_requests_group(session, Request.time_requested > week_ago)
     hits_week_errors = count_requests_group(
-        db_session, and_(Request.time_requested > week_ago, error_hits_criterion)
+        session, and_(Request.time_requested > week_ago, error_hits_criterion)
     )
 
-    hits = count_requests_group(db_session)
+    hits = count_requests_group(session)
 
-    median_today = get_endpoint_data_grouped(db_session, median, Request.time_requested > today_utc)
-    median_week = get_endpoint_data_grouped(db_session, median, Request.time_requested > week_ago)
-    median_overall = get_endpoint_data_grouped(db_session, median)
-    access_times = get_last_requested(db_session)
+    median_today = get_endpoint_data_grouped(session, median, Request.time_requested > today_utc)
+    median_week = get_endpoint_data_grouped(session, median, Request.time_requested > week_ago)
+    median_overall = get_endpoint_data_grouped(session, median)
+    access_times = get_last_requested(session)
 
     return [
         {
@@ -72,21 +72,21 @@ def get_endpoint_overview(db_session):
             'median-overall': get_value(median_overall, endpoint.id),
             'last-accessed': get_value(access_times, endpoint.name, default=None),
         }
-        for endpoint in get_endpoints(db_session)
+        for endpoint in get_endpoints(session)
     ]
 
 
-def get_endpoint_users(db_session, endpoint_id, users):
+def get_endpoint_users(session, endpoint_id, users):
     """
-    :param db_session: session for the database
+    :param session: session for the database
     :param endpoint_id: id for the endpoint
     :param users: a list of users to be filtered on
     :return: a list of dicts with the performance of each user
     """
     times = get_user_data_grouped(
-        db_session, lambda x: simplify(x, 100), Request.endpoint_id == endpoint_id
+        session, lambda x: simplify(x, 100), Request.endpoint_id == endpoint_id
     )
-    first_requests = get_first_requests(db_session, endpoint_id)
+    first_requests = get_first_requests(session, endpoint_id)
     return [
         {
             'user': u,
@@ -98,17 +98,17 @@ def get_endpoint_users(db_session, endpoint_id, users):
     ]
 
 
-def get_endpoint_versions(db_session, endpoint_id, versions):
+def get_endpoint_versions(session, endpoint_id, versions):
     """
-    :param db_session: session for the database
+    :param session: session for the database
     :param endpoint_id: id for the endpoint
     :param versions: a list of version to be filtered on
     :return: a list of dicts with the performance of each version
     """
     times = get_version_data_grouped(
-        db_session, lambda x: simplify(x, 100), Request.endpoint_id == endpoint_id
+        session, lambda x: simplify(x, 100), Request.endpoint_id == endpoint_id
     )
-    first_requests = get_first_requests(db_session, endpoint_id)
+    first_requests = get_first_requests(session, endpoint_id)
     return [
         {
             'version': v,
@@ -120,32 +120,32 @@ def get_endpoint_versions(db_session, endpoint_id, versions):
     ]
 
 
-def get_api_performance(db_session, endpoints):
+def get_api_performance(session, endpoints):
     """
-    :param db_session: session for the database
+    :param session: session for the database
     :param endpoints: a list of endpoints, encoded by their name
     :return: for every endpoint in endpoints, a list with the performance
     """
-    db_endpoints = [get_endpoint_by_name(db_session, end) for end in endpoints]
-    data = get_endpoint_data_grouped(db_session, lambda x: simplify(x, 10))
+    db_endpoints = [get_endpoint_by_name(session, end) for end in endpoints]
+    data = get_endpoint_data_grouped(session, lambda x: simplify(x, 10))
     return [
-        {'name': end.name, 'values': get_value(data, end.id, default=[])} for end in db_endpoints
+        {'name': end.name, 'values': get_value(data, end.id, default=[])}
+        for end in db_endpoints
     ]
 
 
-def set_endpoint_rule(db_session, endpoint_name, monitor_level):
+def set_endpoint_rule(session, endpoint_name, monitor_level):
     """
-    :param db_session: session for the database
+    :param session: session for the database
     :param endpoint_name: name of the endpoint
     :param monitor_level: integer, representing the monitoring-level
-    :return:
     """
-    update_endpoint(db_session, endpoint_name, value=monitor_level)
+    update_endpoint(session, endpoint_name, value=monitor_level)
 
     # Remove wrapper
     original = getattr(config.app.view_functions[endpoint_name], 'original', None)
     if original:
         config.app.view_functions[endpoint_name] = original
-    db_session.commit()
+    session.commit()
 
-    add_decorator(get_endpoint_by_name(db_session, endpoint_name))
+    add_decorator(get_endpoint_by_name(session, endpoint_name))

flask_monitoringdashboard/controllers/outliers.py

@@ -8,13 +8,13 @@
 from flask_monitoringdashboard.database.outlier import get_outliers_cpus, get_outliers_sorted
 
 
-def get_outlier_graph(db_session, endpoint_id):
+def get_outlier_graph(session, endpoint_id):
     """
-    :param db_session: session for the database
+    :param session: session for the database
     :param endpoint_id: id of the endpoint
     :return: a list with data about each CPU performance
     """
-    all_cpus = get_outliers_cpus(db_session, endpoint_id)
+    all_cpus = get_outliers_cpus(session, endpoint_id)
     cpu_data = [ast.literal_eval(cpu) for cpu in all_cpus]
 
     return [
@@ -23,15 +23,15 @@ def get_outlier_graph(db_session, endpoint_id):
     ]
 
 
-def get_outlier_table(db_session, endpoint_id, offset, per_page):
+def get_outlier_table(session, endpoint_id, offset, per_page):
     """
-    :param db_session: session for the database
+    :param session: session for the database
     :param endpoint_id: id of the endpoint
     :param offset: number of items to be skipped
     :param per_page: maximum number of items to be returned
     :return: a list of length at most 'per_page' with data about each outlier
     """
-    table = get_outliers_sorted(db_session, endpoint_id, offset, per_page)
+    table = get_outliers_sorted(session, endpoint_id, offset, per_page)
     for idx, row in enumerate(table):
         row.request.time_requested = to_local_datetime(row.request.time_requested)
         try:

flask_monitoringdashboard/controllers/profiler.py

@@ -11,14 +11,14 @@
 )
 
 
-def get_profiler_table(db_session, endpoint_id, offset, per_page):
+def get_profiler_table(session, endpoint_id, offset, per_page):
     """
-    :param db_session: session for the database
+    :param session: session for the database
     :param endpoint_id: endpoint to filter on
     :param offset: number of items that are skipped
     :param per_page: number of items that are returned (at most)
     """
-    table = get_profiled_requests(db_session, endpoint_id, offset, per_page)
+    table = get_profiled_requests(session, endpoint_id, offset, per_page)
 
     for idx, row in enumerate(table):
         row.time_requested = to_local_datetime(row.time_requested)
@@ -32,14 +32,14 @@ def get_profiler_table(db_session, endpoint_id, offset, per_page):
     return table
 
 
-def get_grouped_profiler(db_session, endpoint_id):
+def get_grouped_profiler(session, endpoint_id):
     """
-    :param db_session: session for the database
+    :param session: session for the database
     :param endpoint_id: endpoint to filter on
     :return:
     """
-    requests = get_grouped_profiled_requests(db_session, endpoint_id)
-    db_session.expunge_all()
+    requests = get_grouped_profiled_requests(session, endpoint_id)
+    session.expunge_all()
 
     histogram = defaultdict(list)  # path -> [list of values]
     path_hash = PathHash()