Merge pull request #537 from aknopper/utcnowfix

Change utcnow to now(datetime.timezone.utc)

Author: mircealungu

docs/changelog.rst

@@ -5,6 +5,23 @@ All notable changes to this project will be documented in this file.
 This project adheres to `Semantic Versioning <http://semver.org/>`_.
 Please note that the changes before version 1.10.0 have not been documented.
 
+v5.0.2
+----------
+**Bug Fix Release**
+
+Fixed
+^^^^^
+- **Build**: Fixed broken 5.0.0 release - Angular frontend is now properly built before publishing to PyPI
+- **Deprecation**: Replaced deprecated ``datetime.utcnow()`` with ``datetime.now(timezone.utc)`` throughout codebase
+- **Deprecation**: Replaced deprecated ``datetime.utcfromtimestamp()`` with ``datetime.fromtimestamp(..., tz=timezone.utc)``
+- **Deprecation**: Replaced ``datetime.UTC`` with ``datetime.timezone.utc`` for Python 3.11+ compatibility
+- **Timezone**: Fixed timezone-aware datetime handling in reporting and database operations
+- **Tests**: Updated test fixtures to properly handle timezone-aware datetimes
+
+Contributors
+^^^^^^^^^^^^
+Special thanks to: Alex Knop (@aknopper) for identifying and fixing the deprecated datetime usage
+
 v5.0.0
 ----------
 **Major Release - Exception Monitoring & Stability Improvements**

flask_monitoringdashboard/controllers/endpoints.py

@@ -32,8 +32,8 @@ def get_endpoint_overview(session):
     :param session: session for the database
     :return: A list of properties for each endpoint that is found in the database
     """
-    week_ago = datetime.datetime.now(datetime.UTC) - datetime.timedelta(days=7)
-    now_local = to_local_datetime(datetime.datetime.now(datetime.UTC))
+    week_ago = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=7)
+    now_local = to_local_datetime(datetime.datetime.now(datetime.timezone.utc))
     today_local = now_local.replace(hour=0, minute=0, second=0, microsecond=0)
     today_utc = to_utc_datetime(today_local)
 

flask_monitoringdashboard/core/cache.py

@@ -69,15 +69,15 @@ def update_last_requested_cache(endpoint_name):
     Use this instead of updating the last requested to the database.
     """
     global memory_cache
-    memory_cache.get(endpoint_name).set_last_requested(datetime.datetime.now(datetime.UTC))
+    memory_cache.get(endpoint_name).set_last_requested(datetime.datetime.now(datetime.timezone.utc))
 
 
 def update_duration_cache(endpoint_name, duration):
     """
     Use this together with adding a request to the database.
     """
     global memory_cache
-    memory_cache.get(endpoint_name).set_last_requested(datetime.datetime.now(datetime.UTC))
+    memory_cache.get(endpoint_name).set_last_requested(datetime.datetime.now(datetime.timezone.utc))
     memory_cache.get(endpoint_name).set_duration(duration)
 
 

flask_monitoringdashboard/core/database_pruning.py

@@ -1,4 +1,4 @@
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from sqlalchemy.orm import Session
 from flask_monitoringdashboard.core.custom_graph import scheduler
 from flask_monitoringdashboard.database import (
@@ -23,7 +23,7 @@
 def prune_database_older_than_weeks(weeks_to_keep, delete_custom_graph_data):
     """Prune the database of Request and optionally CustomGraph data older than the specified number of weeks"""
     with session_scope() as session:
-        date_to_delete_from = datetime.utcnow() - timedelta(weeks=weeks_to_keep)
+        date_to_delete_from = datetime.now(timezone.utc) - timedelta(weeks=weeks_to_keep)
 
         # Prune Request table and related Outlier entries
         requests_to_delete = (

flask_monitoringdashboard/core/telemetry.py

@@ -87,7 +87,7 @@ def initialize_telemetry_session(session):
         else:
             telemetry_user = session.query(TelemetryUser).one()
             telemetry_user.times_initialized += 1
-            telemetry_user.last_initialized = datetime.datetime.now(datetime.UTC)
+            telemetry_user.last_initialized = datetime.datetime.now(datetime.timezone.utc)
             session.commit()
 
         # reset telemetry if declined in previous session

flask_monitoringdashboard/database/__init__.py

@@ -72,7 +72,7 @@ class TelemetryUser(Base):
     times_initialized = Column(Integer, default=1)
     """For checking the amount of times the app was initialized"""
 
-    last_initialized = Column(DateTime, default=datetime.datetime.utcnow)
+    last_initialized = Column(DateTime, default=datetime.datetime.now(datetime.timezone.utc))
     """Check when was the last time user accessed FMD"""
 
     monitoring_consent = Column(Integer, default=1)
@@ -93,7 +93,7 @@ class Endpoint(Base):
     monitor_level = Column(Integer, default=config.monitor_level)
     """0 - disabled, 1 - performance, 2 - outliers, 3 - profiler + outliers"""
 
-    time_added = Column(DateTime, default=datetime.datetime.utcnow)
+    time_added = Column(DateTime, default=datetime.datetime.now(datetime.timezone.utc))
     """Time when the endpoint was added."""
 
     version_added = Column(String(100), default=config.version)
@@ -118,7 +118,7 @@ class Request(Base):
     duration = Column(Float, nullable=False)
     """Processing time of the request in milliseconds."""
 
-    time_requested = Column(DateTime, default=datetime.datetime.utcnow)
+    time_requested = Column(DateTime, default=datetime.datetime.now(datetime.timezone.utc))
     """Moment when the request was handled."""
 
     version_requested = Column(String(100), default=config.version)
@@ -225,7 +225,7 @@ class CustomGraph(Base):
     title = Column(String(250), nullable=False, unique=True)
     """Title of this graph."""
 
-    time_added = Column(DateTime, default=datetime.datetime.utcnow)
+    time_added = Column(DateTime, default=datetime.datetime.now(datetime.timezone.utc))
     """When the graph was first added to the dashboard."""
 
     version_added = Column(String(100), default=config.version)
@@ -244,7 +244,7 @@ class CustomGraphData(Base):
     graph = relationship(CustomGraph, backref="data")
     """Graph for which the data is collected."""
 
-    time = Column(DateTime, default=datetime.datetime.utcnow)
+    time = Column(DateTime, default=datetime.datetime.now(datetime.timezone.utc))
     """Moment when the data is collected."""
 
     value = Column(Float)

flask_monitoringdashboard/database/endpoint.py

@@ -150,7 +150,7 @@ def update_last_requested(session, endpoint_name, timestamp=None):
     :param endpoint_name: name of the endpoint
     :param timestamp: optional timestamp. If not given, timestamp is current time
     """
-    ts = timestamp if timestamp else datetime.datetime.now(datetime.UTC)
+    ts = timestamp if timestamp else datetime.datetime.now(datetime.timezone.utc)
     session.query(Endpoint).filter(Endpoint.name == endpoint_name).update(
         {Endpoint.last_requested: ts}
     )

flask_monitoringdashboard/views/reporting.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 
 from flask import request, jsonify
 from sqlalchemy import and_
@@ -8,18 +8,21 @@
 from flask_monitoringdashboard.core.auth import secure
 from flask_monitoringdashboard.core.date_interval import DateInterval
 from flask_monitoringdashboard.core.telemetry import post_to_back_if_telemetry_enabled
-from flask_monitoringdashboard.core.reporting.questions.median_latency import \
-    MedianLatency
+from flask_monitoringdashboard.core.reporting.questions.median_latency import (
+    MedianLatency,
+)
 from flask_monitoringdashboard.core.reporting.questions.status_code_distribution import (
     StatusCodeDistribution,
 )
 from flask_monitoringdashboard.database import session_scope
 from flask_monitoringdashboard.database.endpoint import get_endpoints
-from flask_monitoringdashboard.database.request import create_time_based_sample_criterion
+from flask_monitoringdashboard.database.request import (
+    create_time_based_sample_criterion,
+)
 
 
 def get_date(p):
-    return datetime.utcfromtimestamp(int(request.args.get(p)))
+    return datetime.fromtimestamp(int(request.args.get(p)), tz=timezone.utc)
 
 
 def make_endpoint_summary(endpoint, requests_criterion, baseline_requests_criterion):
@@ -33,13 +36,14 @@ def make_endpoint_summary(endpoint, requests_criterion, baseline_requests_criter
     )
 
     for question in questions:
-        answer = question.get_answer(endpoint, requests_criterion,
-                                     baseline_requests_criterion)
+        answer = question.get_answer(
+            endpoint, requests_criterion, baseline_requests_criterion
+        )
 
         if answer.is_significant():
-            summary['has_anything_significant'] = True
+            summary["has_anything_significant"] = True
 
-        summary['answers'].append(answer.serialize())
+        summary["answers"].append(answer.serialize())
 
     return summary
 
@@ -49,52 +53,54 @@ def make_endpoint_summaries(requests_criterion, baseline_requests_criterion):
 
     with session_scope() as db_session:
         for endpoint in get_endpoints(db_session):
-            endpoint_summary = make_endpoint_summary(endpoint, requests_criterion,
-                                                     baseline_requests_criterion)
+            endpoint_summary = make_endpoint_summary(
+                endpoint, requests_criterion, baseline_requests_criterion
+            )
             endpoint_summaries.append(endpoint_summary)
 
     return dict(summaries=endpoint_summaries)
 
 
-@blueprint.route('/api/reporting/make_report/intervals', methods=['POST'])
+@blueprint.route("/api/reporting/make_report/intervals", methods=["POST"])
 @secure
 def make_report_intervals():
-    post_to_back_if_telemetry_enabled(**{'name': 'reporting/make_reports/intervals'})
+    post_to_back_if_telemetry_enabled(**{"name": "reporting/make_reports/intervals"})
     arguments = request.json
 
     try:
         interval = DateInterval(
-            datetime.fromtimestamp(int(arguments['interval']['from'])),
-            datetime.fromtimestamp(int(arguments['interval']['to'])),
+            datetime.fromtimestamp(int(arguments["interval"]["from"]), tz=timezone.utc),
+            datetime.fromtimestamp(int(arguments["interval"]["to"]), tz=timezone.utc),
         )
 
         baseline_interval = DateInterval(
-            datetime.fromtimestamp(int(arguments['baseline_interval']['from'])),
-            datetime.fromtimestamp(int(arguments['baseline_interval']['to'])),
+            datetime.fromtimestamp(int(arguments["baseline_interval"]["from"]), tz=timezone.utc),
+            datetime.fromtimestamp(int(arguments["baseline_interval"]["to"]), tz=timezone.utc),
         )
 
     except Exception:
-        return 'Invalid payload', 422
+        return "Invalid payload", 422
 
     baseline_requests_criterion = create_time_based_sample_criterion(
-        baseline_interval.start_date(),
-        baseline_interval.end_date())
-    requests_criterion = create_time_based_sample_criterion(interval.start_date(),
-                                                            interval.end_date())
+        baseline_interval.start_date(), baseline_interval.end_date()
+    )
+    requests_criterion = create_time_based_sample_criterion(
+        interval.start_date(), interval.end_date()
+    )
 
     summaries = make_endpoint_summaries(requests_criterion, baseline_requests_criterion)
 
     return jsonify(summaries)
 
 
-@blueprint.route('/api/reporting/make_report/commits', methods=['POST'])
+@blueprint.route("/api/reporting/make_report/commits", methods=["POST"])
 @secure
 def make_report_commits():
-    post_to_back_if_telemetry_enabled(**{'name': 'reporting/make_reports/commits'})
+    post_to_back_if_telemetry_enabled(**{"name": "reporting/make_reports/commits"})
     arguments = request.json
 
-    baseline_commit_version = arguments['baseline_commit_version']
-    commit_version = arguments['commit_version']
+    baseline_commit_version = arguments["baseline_commit_version"]
+    commit_version = arguments["commit_version"]
 
     if None in [baseline_commit_version, commit_version]:
         return dict(message="Please select two commits"), 422

tests/api/test_custom.py

@@ -1,4 +1,4 @@
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 
 from flask_monitoringdashboard.database import CustomGraph
 
@@ -17,7 +17,7 @@ def test_custom_graphs(dashboard_user, custom_graph, session):
 
 
 def test_custom_graph_data(dashboard_user, custom_graph, custom_graph_data):
-    today = datetime.utcnow()
+    today = datetime.now(timezone.utc)
     yesterday = today - timedelta(days=1)
     response = dashboard_user.get('dashboard/api/custom_graph/{id}/{start}/{end}'.format(
         id=custom_graph.graph_id,

tests/api/test_reporting.py

@@ -1,5 +1,5 @@
 import sys
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 import pytest
 
 from flask_monitoringdashboard.database import Endpoint
@@ -11,24 +11,24 @@ def test_make_report_get(dashboard_user):
     assert not response.is_json
 
 
-@pytest.mark.parametrize('request_1__time_requested', [datetime.utcnow() - timedelta(hours=6)])
+@pytest.mark.parametrize('request_1__time_requested', [datetime.now(timezone.utc) - timedelta(hours=6)])
 @pytest.mark.parametrize('request_1__duration', [5000])
 @pytest.mark.parametrize('request_1__status_code', [500])
-@pytest.mark.parametrize('request_2__time_requested', [datetime.utcnow() - timedelta(days=1, hours=6)])
+@pytest.mark.parametrize('request_2__time_requested', [datetime.now(timezone.utc) - timedelta(days=1, hours=6)])
 @pytest.mark.parametrize('request_2__duration', [100])
 @pytest.mark.skipif(sys.version_info < (3, ), reason="For some reason, this doesn't work in python 2.7.")
 def test_make_report_post_not_significant(dashboard_user, endpoint, request_1, request_2, session):
-    epoch = datetime(1970, 1, 1)
+    epoch = datetime(1970, 1, 1, tzinfo=timezone.utc)
     response = dashboard_user.post(
         'dashboard/api/reporting/make_report/intervals',
         json={
             'interval': {
-                'from': (datetime.utcnow() - timedelta(days=1) - epoch).total_seconds(),
-                'to': (datetime.utcnow() - epoch).total_seconds(),
+                'from': (datetime.now(timezone.utc) - timedelta(days=1) - epoch).total_seconds(),
+                'to': (datetime.now(timezone.utc) - epoch).total_seconds(),
             },
             'baseline_interval': {
-                'from': (datetime.utcnow() - timedelta(days=2) - epoch).total_seconds(),
-                'to': (datetime.utcnow() - timedelta(days=1) - epoch).total_seconds(),
+                'from': (datetime.now(timezone.utc) - timedelta(days=2) - epoch).total_seconds(),
+                'to': (datetime.now(timezone.utc) - timedelta(days=1) - epoch).total_seconds(),
             },
         },
     )