add int test

Author: yec-akamai

linode_api4/groups/monitor_api.py

@@ -2,10 +2,12 @@
     "MetricsGroup",
 ]
 
-from typing import Optional
+from typing import Any, Dict, List, Optional, Union
 
+from linode_api4 import drop_null_keys
 from linode_api4.groups import Group
-from linode_api4.objects.monitor_api import EntityMetrics
+from linode_api4.objects.base import _flatten_request_body_recursive
+from linode_api4.objects.monitor_api import EntityMetricOptions, EntityMetrics
 
 
 class MetricsGroup(Group):
@@ -19,6 +21,7 @@ def fetch_metrics(
         self,
         service_type: str,
         entity_ids: list,
+        metrics: List[Union[EntityMetricOptions, Dict[str, Any]]],
         **kwargs,
     ) -> Optional[EntityMetrics]:
         """
@@ -33,18 +36,24 @@ def fetch_metrics(
         :param entity_ids: The id for each individual entity from a service_type.
         :type entity_ids: list
 
+        :param metrics: A list of metric objects, each specifying a metric name and its corresponding aggregation function.
+        :type metrics: list of EntityMetricOptions or Dict[str, Any]
+
         :param kwargs: Any other arguments accepted by the api. Please refer to the API documentation for full info.
 
         :returns: Service metrics requested.
         :rtype: EntityMetrics or None
         """
-
-        params = {"entity_ids": entity_ids}
+        params = {
+            "entity_ids": entity_ids,
+            "metrics": metrics,
+        }
 
         params.update(kwargs)
 
         result = self.client.post(
-            f"/monitor/services/{service_type}/metrics", data=params
+            f"/monitor/services/{service_type}/metrics",
+            data=drop_null_keys(_flatten_request_body_recursive(params)),
         )
 
         return EntityMetrics.from_json(result)

linode_api4/linode_client.py

@@ -53,6 +53,43 @@ def get_backoff_time(self):
 
 
 class BaseClient:
+    """
+    The base class for a client.
+
+    :param token: The authentication token to use for communication with the
+                  API.  Can be either a Personal Access Token or an OAuth Token.
+    :type token: str
+    :param base_url: The base URL for API requests.  Generally, you shouldn't
+                     change this.
+    :type base_url: str
+    :param user_agent: What to append to the User Agent of all requests made
+                       by this client.  Setting this allows Linode's internal
+                       monitoring applications to track the usage of your
+                       application.  Setting this is not necessary, but some
+                       applications may desire this behavior.
+    :type user_agent: str
+    :param page_size: The default size to request pages at.  If not given,
+                              the API's default page size is used.  Valid values
+                              can be found in the API docs, but at time of writing
+                              are between 25 and 500.
+    :type page_size: int
+    :param retry: Whether API requests should automatically be retries on known
+                  intermittent responses.
+    :type retry: bool
+    :param retry_rate_limit_interval: The amount of time to wait between HTTP request
+                                      retries.
+    :type retry_rate_limit_interval: Union[float, int]
+    :param retry_max: The number of request retries that should be attempted before
+                      raising an API error.
+    :type retry_max: int
+    :type retry_statuses: List of int
+    :param retry_statuses: Additional HTTP response statuses to retry on.
+                           By default, the client will retry on 408, 429, and 502
+                           responses.
+    :param ca_path: The path to a CA file to use for API requests in this client.
+    :type ca_path: str
+    """
+
     def __init__(
         self,
         token,

linode_api4/objects/monitor.py

@@ -3,6 +3,7 @@
     "MonitorMetricsDefinition",
     "MonitorService",
     "MonitorServiceToken",
+    "AggregateFunction",
 ]
 from dataclasses import dataclass, field
 from typing import List, Optional

linode_api4/objects/monitor_api.py

@@ -3,10 +3,12 @@
     "EntityMetricsData",
     "EntityMetricsDataResult",
     "EntityMetricsStats",
+    "EntityMetricOptions",
 ]
 from dataclasses import dataclass, field
 from typing import List, Optional
 
+from linode_api4.objects.monitor import AggregateFunction
 from linode_api4.objects.serializable import JSONObject
 
 
@@ -34,3 +36,9 @@ class EntityMetrics(JSONObject):
     isPartial: bool = False
     stats: Optional[EntityMetricsStats] = None
     status: str = ""
+
+
+@dataclass
+class EntityMetricOptions(JSONObject):
+    name: str = ""
+    aggregate_function: AggregateFunction = ""

test/integration/conftest.py

@@ -5,15 +5,21 @@
 from test.integration.helpers import (
     get_test_label,
     send_request_when_resource_available,
+    wait_for_condition,
 )
+from test.integration.models.database.helpers import get_db_engine_id
 from typing import Optional, Set
 
 import pytest
 import requests
 from requests.exceptions import ConnectionError, RequestException
 
-from linode_api4 import PlacementGroupPolicy, PlacementGroupType
-from linode_api4.linode_client import LinodeClient
+from linode_api4 import (
+    PlacementGroupPolicy,
+    PlacementGroupType,
+    PostgreSQLDatabase,
+)
+from linode_api4.linode_client import LinodeClient, MonitorClient
 from linode_api4.objects import Region
 
 ENV_TOKEN_NAME = "LINODE_TOKEN"
@@ -521,3 +527,68 @@ def linode_for_vlan_tests(test_linode_client, e2e_test_firewall):
     yield linode_instance
 
     linode_instance.delete()
+
+
+@pytest.fixture(scope="session")
+def test_create_postgres_db(test_linode_client):
+    client = test_linode_client
+    label = get_test_label() + "-postgresqldb"
+    region = "us-ord"
+    engine_id = get_db_engine_id(client, "postgresql")
+    dbtype = "g6-standard-1"
+
+    db = client.database.postgresql_create(
+        label=label,
+        region=region,
+        engine=engine_id,
+        ltype=dbtype,
+        cluster_size=None,
+    )
+
+    def get_db_status():
+        return db.status == "active"
+
+    # TAKES 15-30 MINUTES TO FULLY PROVISION DB
+    wait_for_condition(60, 2000, get_db_status)
+
+    yield db
+
+    send_request_when_resource_available(300, db.delete)
+
+
+@pytest.fixture(scope="session")
+def get_monitor_token_for_db_entities(test_linode_client):
+    client = test_linode_client
+
+    dbs = client.database.postgresql_instances()
+
+    if len(dbs) < 1:
+        db_id = test_create_postgres_db.id
+    else:
+        db_id = dbs[0].id
+
+    region = client.load(PostgreSQLDatabase, db_id).region
+    dbs = client.database.instances()
+
+    # only collect entity_ids in the same region
+    entity_ids = [db.id for db in dbs if db.region == region]
+
+    # create token for the particular service
+    token = client.monitor.create_token(
+        service_type="dbaas", entity_ids=entity_ids
+    )
+
+    yield token, entity_ids
+
+
+@pytest.fixture(scope="session")
+def test_monitor_client(get_monitor_token_for_db_entities):
+    api_ca_file = get_api_ca_file()
+    token, entity_ids = get_monitor_token_for_db_entities
+
+    client = MonitorClient(
+        token.token,
+        ca_path=api_ca_file,
+    )
+
+    return client, entity_ids

test/integration/models/monitor_api/test_monitor_api.py

@@ -0,0 +1,12 @@
+def test_monitor_api_fetch_dbaas_metrics(test_monitor_client):
+    client, entity_ids = test_monitor_client
+
+    metrics = client.metrics.fetch_metrics(
+        "dbaas",
+        entity_ids=entity_ids,
+        metrics=[{"name": "read_iops", "aggregate_function": "avg"}],
+        relative_time_duration={"unit": "hr", "value": 1},
+    )
+
+    assert metrics.status == "success"
+    assert len(metrics.data.result) > 0

test/unit/groups/monitor_api_test.py

@@ -1,5 +1,7 @@
 from test.unit.base import MonitorClientBaseCase
 
+from linode_api4.objects import AggregateFunction, EntityMetricOptions
+
 
 class MonitorAPITest(MonitorClientBaseCase):
     """
@@ -14,8 +16,11 @@ def test_fetch_metrics(self):
                 service_type,
                 entity_ids=[13217, 13316],
                 metrics=[
-                    {"name": "avg_read_iops", "aggregate": "avg"},
-                    {"name": "avg_cpu_usage", "aggregate": "avg"},
+                    EntityMetricOptions(
+                        name="avg_read_iops",
+                        aggregate_function=AggregateFunction("avg"),
+                    ),
+                    {"name": "avg_cpu_usage", "aggregate_function": "avg"},
                 ],
                 relative_time_duration={"unit": "hr", "value": 1},
             )
@@ -25,8 +30,8 @@ def test_fetch_metrics(self):
             assert m.call_data == {
                 "entity_ids": [13217, 13316],
                 "metrics": [
-                    {"name": "avg_read_iops", "aggregate": "avg"},
-                    {"name": "avg_cpu_usage", "aggregate": "avg"},
+                    {"name": "avg_read_iops", "aggregate_function": "avg"},
+                    {"name": "avg_cpu_usage", "aggregate_function": "avg"},
                 ],
                 "relative_time_duration": {"unit": "hr", "value": 1},
             }