qdb-cloudwatch 3.14.2__py3-none-any.whl

qdb_cloudwatch/__main__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+from .driver import main
+
+main()

qdb_cloudwatch/check.py

@@ -0,0 +1,177 @@
+import copy
+import json
+import logging
+import random
+import re
+import uuid
+
+import quasardb
+import quasardb.stats as qdbst
+
+logger = logging.getLogger(__name__)
+
+
+def _slurp(x):
+    with open(x, "r") as fp:
+        return fp.read()
+
+
+def _parse_user_security_file(x):
+    with open(x, "r") as fp:
+        parsed = json.load(fp)
+        return (parsed["username"], parsed["secret_key"])
+
+
+def get_qdb_conn(uri, cluster_public_key=None, user_security_file=None):
+    logger.info("Getting qdb connection")
+    if cluster_public_key and user_security_file:
+        user, private_key = _parse_user_security_file(user_security_file)
+        public_key = _slurp(cluster_public_key)
+        return quasardb.Cluster(
+            uri,
+            user_name=user,
+            user_private_key=private_key,
+            cluster_public_key=public_key,
+        )
+    else:
+        return quasardb.Cluster(uri)
+
+
+def _check_node_online(conn):
+    logger.info("Checking node online")
+    ret = {}
+
+    for endpoint in conn.endpoints():
+        ret[endpoint] = 0  # pessimistic
+        node = conn.node(endpoint)
+        entry = node.integer("$qdb.statistics.startup_epoch")  # entry always exists
+
+        try:
+            entry.get()
+            ret[endpoint] = 1
+        except quasardb.Error as e:
+            logger.error(f"[{endpoint}] Failed to read sample entry: {e}")
+
+    return ret
+
+
+def _check_node_writable(conn):
+    logger.info("Checking node writable")
+    key = f"_qdb_write_check_{uuid.uuid4().hex}"  # almost zero chance of collision
+    value = random.randint(-9223372036854775808, 9223372036854775807)
+    ret = {}
+
+    for endpoint in conn.endpoints():
+        ret[endpoint] = 0  # pessimistic
+        node = conn.node(endpoint)
+        entry = node.integer(key)
+
+        try:
+            entry.put(value)
+            if entry.get() == value:
+                ret[endpoint] = 1
+        except quasardb.Error as e:
+            logger.error(f"[{endpoint}] Failed to put/get test entry '{key}': {e}")
+        finally:
+            try:
+                entry.remove()
+            except quasardb.AliasNotFoundError:
+                pass
+            except quasardb.Error as e:
+                logger.error(f"[{endpoint}] Failed to clean up test entry '{key}': {e}")
+
+    return ret
+
+
+def get_critical_stats(*args, **kwargs):
+    """
+    Return the minimal set of cluster health metrics required for alerting.
+
+    These metrics (i.e., `check.online` and `node.writable`) are the ones that
+    feed CloudWatch alarms and signal conditions that require immediate action.
+    By contrast, high-volume or informational metrics (cache usage, RocksDB
+    internals, etc.) are non-critical because they are (usually) not part of the
+    alerting path.
+
+    Future extensions may allow users to define their own critical metrics.
+    """
+    logger.info("Getting critical stats")
+    with get_qdb_conn(*args, **kwargs) as conn:
+        ret = {
+            endpoint: {"cumulative": {}, "by_uid": {}} for endpoint in conn.endpoints()
+        }
+        online_stats = _check_node_online(conn)
+        writable_stats = _check_node_writable(conn)
+
+        for endpoint in conn.endpoints():
+            ret[endpoint]["cumulative"]["check.online"] = {
+                "value": online_stats.get(endpoint, 0),
+                "type": qdbst.Type.GAUGE,
+                "unit": qdbst.Unit.NONE,
+            }
+            ret[endpoint]["cumulative"]["node.writable"] = {
+                "value": writable_stats.get(endpoint, 0),
+                "type": qdbst.Type.GAUGE,
+                "unit": qdbst.Unit.NONE,
+            }
+
+        return ret
+
+
+def get_all_stats(*args, **kwargs):
+    logger.info("Getting all the stats")
+    with get_qdb_conn(*args, **kwargs) as conn:
+        ret = qdbst.by_node(conn)
+        return ret
+
+
+def _do_filter_metrics(metrics, fn):
+    return {key: metrics[key] for key in metrics if fn(key)}
+
+
+def _do_filter(stats, fn):
+    """
+    Performs actual filtering of stats, keeping only those where fn(name) equals True
+    """
+
+    for node_id in stats:
+        for group_id in stats[node_id]:
+            if group_id == "cumulative":
+                stats[node_id][group_id] = _do_filter_metrics(
+                    stats[node_id][group_id], fn
+                )
+            elif group_id == "by_uid":
+                for uid in stats[node_id][group_id]:
+                    stats[node_id][group_id][uid] = _do_filter_metrics(
+                        stats[node_id][group_id][uid], fn
+                    )
+            else:
+                raise RuntimeError(
+                    "Internal error: unrecognized stats group id: {}".format(group_id)
+                )
+    return stats
+
+
+def filter_stats(stats, include=None, exclude=None):
+    logger.info("Filtering stats based on include/exclude filters")
+    stats_ = copy.deepcopy(stats)
+
+    if include is not None:
+        # Returns `true` if any of the `include` patterns is found in the metric name.
+        def _filter_include(metric_name):
+            return any(
+                pattern for pattern in include if re.search(pattern, metric_name)
+            )
+
+        stats_ = _do_filter(stats_, _filter_include)
+
+    if exclude is not None:
+        # Returns `false` if any of the `exclude` patterns is found in the metric name.
+        def _filter_exclude(metric_name):
+            return not any(
+                pattern for pattern in exclude if re.search(pattern, metric_name)
+            )
+
+        stats_ = _do_filter(stats_, _filter_exclude)
+
+    return stats_

qdb_cloudwatch/cloudwatch.py

@@ -0,0 +1,92 @@
+import logging
+
+import boto3
+from quasardb.stats import Unit
+
+logger = logging.getLogger(__name__)
+
+_stat_unit_to_cloudwatch_unit = {
+    Unit.NONE: "None",
+    Unit.COUNT: "Count",
+    Unit.BYTES: "Bytes",
+    Unit.EPOCH: "None",
+    Unit.NANOSECONDS: "None",
+    Unit.MICROSECONDS: "Microseconds",
+    Unit.MILLISECONDS: "Milliseconds",
+    Unit.SECONDS: "Seconds",
+}
+
+
+def _get_client():
+    logger.info("Getting cloudwatch client")
+    return boto3.client("cloudwatch")
+
+
+def _coerce_metric(k, v):
+    if k.startswith("cpu."):
+        # We don't expose CPU metrics through Cloudwatch, as this is already collected
+        # by the regular metrics.
+        return None
+
+    if v["unit"] == Unit.NANOSECONDS:
+        v["unit"] = Unit.MICROSECONDS
+        v["value"] /= 1000
+
+    return (_stat_unit_to_cloudwatch_unit.get(v["unit"], "None"), float(v["value"]))
+
+
+def _to_metric(k, v):
+    try:
+        x = _coerce_metric(k, v)
+        if x:
+            (u, v_) = x
+            return {"MetricName": k, "Value": v_, "Unit": u}
+    except:
+        logger.debug(f"The key '{k}' cannot be sent")
+        return None
+
+
+def _qdb_to_cloudwatch(stats):
+    # We want to flatten all metrics into a tuple of 3 items:
+    # - node_id
+    # - user_id
+    # - measurement
+
+    ret = list()
+
+    for node_id, xs in stats.items():
+        for user_id, xs_ in xs["by_uid"].items():
+            dims = [
+                {"Name": "UserId", "Value": str(user_id)},
+                {"Name": "NodeId", "Value": str(node_id)},
+            ]
+            for k, v in xs_.items():
+                m = _to_metric(k, v)
+                if m:
+                    m["Dimensions"] = dims
+                    ret.append(m)
+
+        dims = [{"Name": "NodeId", "Value": str(node_id)}]
+        for k, v in xs["cumulative"].items():
+            m = _to_metric(k, v)
+            if m:
+                m["Dimensions"] = dims
+                ret.append(m)
+
+    return ret
+
+
+def push_stats(stats, namespace):
+    client = _get_client()
+    stats_ = _qdb_to_cloudwatch(stats)
+
+    metrics_per_req = 20
+    metrics = [
+        stats_[i : i + metrics_per_req] for i in range(0, len(stats_), metrics_per_req)
+    ]
+
+    logger.info(f"Pushing {len(stats_)} metrics")
+    for metric in metrics:
+        _ = client.put_metric_data(Namespace=namespace, MetricData=metric)
+
+    logger.info(f"Pushed {len(stats_)} metrics")

qdb_cloudwatch/driver.py

@@ -0,0 +1,106 @@
+import argparse
+import logging
+import sys
+
+from .check import filter_stats, get_all_stats, get_critical_stats
+from .cloudwatch import push_stats
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_list(x):
+    """
+    Parses a comma-separated string into a list.
+    """
+
+    if x is None or not x.strip():
+        return None
+
+    return [token.strip() for token in x.split(",") if token.strip()]
+
+
+def get_args():
+    parser = argparse.ArgumentParser(
+        description=("Fetch QuasarDB metrics for local node and export to CloudWatch.")
+    )
+    parser.add_argument(
+        "--cluster",
+        dest="cluster_uri",
+        help="QuasarDB cluster uri to connect to. Defaults to qdb://127.0.0.1:2836",
+        default="qdb://127.0.0.1:2836",
+    )
+
+    parser.add_argument(
+        "--cluster-public-key",
+        dest="cluster_public_key",
+        help="Cluster public key file",
+    )
+
+    parser.add_argument(
+        "--user-security-file",
+        dest="user_security_file",
+        help="User security file, containing both username and private access token.",
+    )
+
+    parser.add_argument(
+        "--node-id",
+        dest="node_id",
+        help="Node id to collect metrics from, e.g. 0-0-0-1",
+    )
+
+    parser.add_argument(
+        "--namespace",
+        dest="namespace",
+        help="Namespace for metrics",
+        default="QuasarDB",
+    )
+
+    parser.add_argument(
+        "--filter-include",
+        dest="filter_include",
+        help="Optional comma-separated list of regex patterns to filter metrics. Only metrics that match at least one of the patterns will be reported.",
+    )
+
+    parser.add_argument(
+        "--filter-exclude",
+        dest="filter_exclude",
+        help="Optional comma-separated list of regex patterns to filter metrics. Only metrics that contain none of the patterns will be reported.",
+    )
+
+    ret = parser.parse_args()
+
+    ret.filter_include = _parse_list(ret.filter_include)
+    ret.filter_exclude = _parse_list(ret.filter_exclude)
+
+    if ret.filter_include is not None:
+        logger.info(f"Using include filters: {ret.filter_include}")
+
+    if ret.filter_exclude is not None:
+        logger.info(f"Using exclude filters: {ret.filter_exclude}")
+
+    return ret
+
+
+def main():
+    logging.basicConfig(stream=sys.stderr, level=logging.INFO)
+
+    args = get_args()
+
+    # Send critical stats first, as getting all stats is expensive when cluster is busy.
+    critical_stats = get_critical_stats(
+        args.cluster_uri,
+        cluster_public_key=args.cluster_public_key,
+        user_security_file=args.user_security_file,
+    )
+    push_stats(critical_stats, args.namespace)
+
+    stats = get_all_stats(
+        args.cluster_uri,
+        cluster_public_key=args.cluster_public_key,
+        user_security_file=args.user_security_file,
+    )
+    stats = filter_stats(
+        stats, include=args.filter_include, exclude=args.filter_exclude
+    )
+
+    push_stats(stats, args.namespace)

qdb_cloudwatch-3.14.2.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: qdb-cloudwatch
+Version: 3.14.2
+Summary: Export QuasarDB statistics to AWS Cloudwatch
+License-File: LICENSE.md
+Requires-Dist: boto3>=1.9
+Requires-Dist: quasardb==3.14.2
+Provides-Extra: pandas
+Requires-Dist: pandas; extra == "pandas"
+Provides-Extra: tests
+Requires-Dist: pytest>=6.2.5; extra == "tests"
+Requires-Dist: pytest-runner>=5.3.1; extra == "tests"
+Requires-Dist: teamcity-messages>=1.29; extra == "tests"
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary

qdb_cloudwatch-3.14.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+qdb_cloudwatch/__main__.py,sha256=lmRCPGcwYGFyA6gjdtrSHcUSnkh_XvpkvFPQaYxQyq4,58
+qdb_cloudwatch/check.py,sha256=IrOe7BRZF5WE7bwj_QFjilWsVjruk2c43BMxD5ZGy5M,5538
+qdb_cloudwatch/cloudwatch.py,sha256=6sut8Ak568Cf_Nb1E-GaZL6SYHXKlzxxzCnHKtm1M4s,2376
+qdb_cloudwatch/driver.py,sha256=3_tRFRARyatJBaqLmIgKe3_AmYfknO448hxUNn_yZvw,2946
+qdb_cloudwatch-3.14.2.dist-info/licenses/LICENSE.md,sha256=fRy4x7atA0XNtRPb3BoZSxxkkUaGzVPmNkqKrpTXW1c,1466
+qdb_cloudwatch-3.14.2.dist-info/METADATA,sha256=vyzot_NvSmoL2bwWnLNR6TyvM7ORNmWifeyu8FIICDs,526
+qdb_cloudwatch-3.14.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qdb_cloudwatch-3.14.2.dist-info/entry_points.txt,sha256=Bd9rDwsoDrlpU6o_hpRP4N5BuzY92CK7Jf7ZkVlf-fw,62
+qdb_cloudwatch-3.14.2.dist-info/top_level.txt,sha256=MtJaeN-kaZ96VKDZJhPTr5bL6Kj_3pgU1-iK6mSnuGI,15
+qdb_cloudwatch-3.14.2.dist-info/RECORD,,

qdb_cloudwatch-3.14.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

qdb_cloudwatch-3.14.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qdb-cloudwatch = qdb_cloudwatch.driver:main

qdb_cloudwatch-3.14.2.dist-info/licenses/LICENSE.md

@@ -0,0 +1,11 @@
+Copyright (c) 2009-2019, quasardb SAS All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+Neither the name of quasardb nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

qdb_cloudwatch-3.14.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+qdb_cloudwatch