Add version metadata

postgres/datadog_checks/postgres/postgres.py

@@ -40,7 +40,7 @@
     STATIO_METRICS,
     fmt,
 )
-from .version_utils import V8_3, V9, V9_1, V9_2, V9_4, V9_6, V10, get_version
+from .version_utils import V8_3, V9, V9_1, V9_2, V9_4, V9_6, V10, get_raw_version, parse_version, transform_version
 
 MAX_CUSTOM_RESULTS = 100
 TABLE_COUNT_LIMIT = 200
@@ -59,6 +59,7 @@ class PostgreSql(AgentCheck):
     GAUGE = AgentCheck.gauge
     MONOTONIC = AgentCheck.monotonic_count
     SERVICE_CHECK_NAME = 'postgres.can_connect'
+    METADATA_TRANSFORMERS = {'version': transform_version}
 
     def __init__(self, name, init_config, instances):
         AgentCheck.__init__(self, name, init_config, instances)
@@ -124,8 +125,9 @@ def _get_replication_role(self):
     @property
     def version(self):
         if self._version is None:
-            self._version = get_version(self.db)
-            self.service_metadata('version', [self._version.major, self._version.minor, self._version.patch])
+            raw_version = get_raw_version(self.db)
+            self._version = parse_version(raw_version)
+            self.set_metadata('version', raw_version)
         return self._version
 
     def _get_instance_metrics(self, database_size_metrics, collect_default_db):
@@ -722,7 +724,7 @@ def check(self, instance):
             self._connect(host, port, user, password, dbname, ssl, tags)
             if tag_replication_role:
                 tags.extend(["replication_role:{}".format(self._get_replication_role())])
-            self.log.debug("Running check against version %s", self.version)
+            self.log.debug("Running check against version %s", str(self.version))
             self._collect_stats(
                 user,
                 tags,
@@ -749,3 +751,4 @@ def check(self, instance):
                 self.db.commit()
             except Exception as e:
                 self.log.warning("Unable to commit: %s", e)
+        self._version = None  # We don't want to cache versions between runs to capture minor updates for metadata

postgres/datadog_checks/postgres/version_utils.py

@@ -14,25 +14,48 @@
 V10 = semver.parse("10.0.0")
 
 
-def get_version(db):
+def get_raw_version(db):
     cursor = db.cursor()
     cursor.execute('SHOW SERVER_VERSION;')
     raw_version = cursor.fetchone()[0]
+    return raw_version
+
+
+def parse_version(raw_version):
+    try:
+        # Only works for MAJOR.MINOR.PATCH(-PRE_RELEASE)
+        return semver.parse_version_info(raw_version)
+    except ValueError:
+        pass
     try:
-        version_parts = raw_version.split(' ')[0].split('.')
-        version = [int(part) for part in version_parts]
+        # Version may be missing minor eg: 10.0
+        version = raw_version.split(' ')[0].split('.')
+        version = [int(part) for part in version]
         while len(version) < 3:
             version.append(0)
         return semver.VersionInfo(*version)
-    except Exception:
+    except ValueError:
         # Postgres might be in development, with format \d+[beta|rc]\d+
         match = re.match(r'(\d+)([a-zA-Z]+)(\d+)', raw_version)
         if match:
             version = list(match.groups())
-            # We found a valid development version
-            if len(version) == 3:
-                # Replace development tag with a negative number to properly compare versions
-                version[1] = -1
-                version = [int(part) for part in version]
-            return semver.VersionInfo(*version)
+            return semver.parse_version_info('{}.0.0-{}.{}'.format(*version))
     raise Exception("Cannot determine which version is {}".format(raw_version))
+
+
+def transform_version(raw_version, options=None):
+    """
+    :param raw_version: raw version in str format
+    :param options: keyword arguments to pass to any defined transformer
+    """
+    version = parse_version(raw_version)
+    transformed = {
+        'version.major': str(version.major),
+        'version.minor': str(version.minor),
+        'version.patch': str(version.patch),
+        'version.raw': raw_version,
+        'version.scheme': 'semver',
+    }
+    if version.prerelease:
+        transformed['version.release'] = version.prerelease
+    return transformed

postgres/tests/test_integration.py

@@ -134,10 +134,28 @@ def test_wrong_version(aggregator, integration_check, pg_instance):
     assert_state_clean(check)
 
     check.check(pg_instance)
-    assert check._version.major == int(POSTGRES_VERSION)
     assert_state_set(check)
 
 
+@pytest.mark.integration
+@pytest.mark.usefixtures('dd_environment')
+def test_version_metadata(integration_check, pg_instance, datadog_agent):
+    check = integration_check(pg_instance)
+    check.check_id = 'test:123'
+    # Enforce to cache wrong version
+    check.check(pg_instance)
+    version = POSTGRES_VERSION.split('.')
+    version_metadata = {
+        'version.scheme': 'semver',
+        'version.major': version[0],
+    }
+    if len(version) == 2:
+        version_metadata['version.minor'] = version[1]
+
+    datadog_agent.assert_metadata('test:123', version_metadata)
+    datadog_agent.assert_metadata_count(5)  # for raw and patch
+
+
 @pytest.mark.integration
 @pytest.mark.usefixtures('dd_environment')
 def test_state_clears_on_connection_error(integration_check, pg_instance):
@@ -160,7 +178,6 @@ def throw_exception_first_time(*args, **kwargs):
 
 
 def assert_state_clean(check):
-    assert check._version is None
     assert check.instance_metrics is None
     assert check.bgw_metrics is None
     assert check.archiver_metrics is None
@@ -170,8 +187,7 @@ def assert_state_clean(check):
     assert check.activity_metrics is None
 
 
-def assert_state_set(check,):
-    assert check._version
+def assert_state_set(check):
     assert check.instance_metrics
     assert check.bgw_metrics
     if POSTGRES_VERSION != '9.3':

postgres/tests/test_unit.py

@@ -1,10 +1,12 @@
 # (C) Datadog, Inc. 2018
 # All rights reserved
 # Licensed under Simplified BSD License (see LICENSE)
+import mock
 import psycopg2
 import pytest
 from mock import MagicMock
 from semver import VersionInfo
+from six import iteritems
 
 from datadog_checks.postgres import util
 
@@ -172,3 +174,24 @@ def test_malformed_get_custom_queries(check):
         malformed_custom_query_column['name'],
         malformed_custom_query['metric_prefix'],
     )
+
+
+@pytest.mark.parametrize(
+    'test_case, params',
+    [
+        ('9.6.2', {'version.major': '9', 'version.minor': '6', 'version.patch': '2'}),
+        ('10.0', {'version.major': '10', 'version.minor': '0', 'version.patch': '0'}),
+        (
+            '11nightly3',
+            {'version.major': '11', 'version.minor': '0', 'version.patch': '0', 'version.release': 'nightly.3'},
+        ),
+    ],
+)
+def test_version_metadata(check, test_case, params):
+    check.check_id = 'test:123'
+    with mock.patch('datadog_checks.base.stubs.datadog_agent.set_check_metadata') as m:
+        check.set_metadata('version', test_case)
+        for name, value in iteritems(params):
+            m.assert_any_call('test:123', name, value)
+        m.assert_any_call('test:123', 'version.scheme', 'semver')
+        m.assert_any_call('test:123', 'version.raw', test_case)

postgres/tests/test_version_utils.py

@@ -2,44 +2,77 @@
 # All rights reserved
 # Licensed under Simplified BSD License (see LICENSE)
 import pytest
-from mock import MagicMock
 from semver import VersionInfo
 
-from datadog_checks.postgres.version_utils import get_version
+from datadog_checks.postgres.version_utils import parse_version, transform_version
 
 pytestmark = pytest.mark.unit
 
 
-def test_get_version():
+def test_parse_version():
     """
     Test _get_version() to make sure the check is properly parsing Postgres versions
     """
-    db = MagicMock()
-
-    # Test #.#.# style versions
-    db.cursor().fetchone.return_value = ['9.5.3']
-    assert get_version(db) == VersionInfo(9, 5, 3)
+    version = parse_version('9.5.3')
+    assert version == VersionInfo(9, 5, 3)
 
     # Test #.# style versions
-    db.cursor().fetchone.return_value = ['10.2']
-    assert get_version(db) == VersionInfo(10, 2, 0)
+    v10_2 = parse_version('10.2')
+    assert v10_2 == VersionInfo(10, 2, 0)
+
+    v11 = parse_version('11')
+    assert v11 == VersionInfo(11, 0, 0)
 
     # Test #beta# style versions
-    db.cursor().fetchone.return_value = ['11beta3']
-    assert get_version(db) == VersionInfo(11, -1, 3)
+    beta11 = parse_version('11beta3')
+    assert beta11 == VersionInfo(11, 0, 0, prerelease='beta.3')
+
+    assert v10_2 < beta11
+    assert v11 > beta11
 
     # Test #rc# style versions
-    db.cursor().fetchone.return_value = ['11rc1']
-    assert get_version(db) == VersionInfo(11, -1, 1)
+    version = parse_version('11rc1')
+    assert version == VersionInfo(11, 0, 0, prerelease='rc.1')
 
     # Test #nightly# style versions
-    db.cursor().fetchone.return_value = ['11nightly3']
-    assert get_version(db) == VersionInfo(11, -1, 3)
+    version = parse_version('11nightly3')
+    assert version == VersionInfo(11, 0, 0, 'nightly.3')
 
 
 def test_throws_exception_for_unknown_version_format():
-    db = MagicMock()
-    db.cursor().fetchone.return_value = ['dontKnow']
     with pytest.raises(Exception) as e:
-        get_version(db)
+        parse_version('dontKnow')
     assert e.value.args[0] == "Cannot determine which version is dontKnow"
+
+
+def test_transform_version():
+    version = transform_version('11beta4')
+    expected = {
+        'version.raw': '11beta4',
+        'version.major': '11',
+        'version.minor': '0',
+        'version.patch': '0',
+        'version.release': 'beta.4',
+        'version.scheme': 'semver',
+    }
+    assert expected == version
+
+    version = transform_version('10.0')
+    expected = {
+        'version.raw': '10.0',
+        'version.major': '10',
+        'version.minor': '0',
+        'version.patch': '0',
+        'version.scheme': 'semver',
+    }
+    assert expected == version
+
+    version = transform_version('10.5.4')
+    expected = {
+        'version.raw': '10.5.4',
+        'version.major': '10',
+        'version.minor': '5',
+        'version.patch': '4',
+        'version.scheme': 'semver',
+    }
+    assert expected == version

postgres/tests/utils.py

@@ -5,4 +5,7 @@
 
 from .common import POSTGRES_VERSION
 
-requires_over_10 = pytest.mark.skipif(float(POSTGRES_VERSION) < 10, reason='This test is for over 10 only')
+requires_over_10 = pytest.mark.skipif(
+    POSTGRES_VERSION is None or float(POSTGRES_VERSION) < 10,
+    reason='This test is for over 10 only (make sure POSTGRES_VERSION is set)',
+)