datadog-smartd 0.1.0__tar.gz

datadog_smartd-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+.pytest_cache/
+*.whl

datadog_smartd-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

datadog_smartd-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: datadog-smartd
+Version: 0.1.0
+Summary: The smartd check
+Project-URL: Source, https://github.com/DataDog/integrations-extras
+Author: Community
+License-Expression: MIT
+License-File: LICENSE
+Keywords: datadog,datadog agent,datadog check,smart,smartd
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.13
+Requires-Dist: datadog-checks-base>=37.33.0
+Provides-Extra: deps
+Description-Content-Type: text/markdown
+
+# smartd
+
+## Overview
+
+This integration monitors [S.M.A.R.T.][1] disk health by reading state files written by the [smartd][2] daemon (part of [smartmontools][3]). It collects key disk health attributes such as temperature, reallocated sectors, power-on hours, and pending sector counts, and reports the overall health status of each drive as a service check.
+
+Unlike other approaches that shell out to `smartctl` (which requires root privileges), this integration reads the state files that `smartd` already maintains, making it work without any privilege escalation.
+
+## Setup
+
+### Prerequisites
+
+- The `smartd` daemon must be running and writing state files (default location: `/var/lib/smartmontools/`).
+- The `dd-agent` user must have read access to the state files (they are typically world-readable with `644` permissions).
+
+### Installation
+
+For development, install the check in the Datadog Agent's Python environment:
+
+```bash
+datadog-agent integration install -e /path/to/smartd
+```
+
+For production, copy the check file and configuration:
+
+```bash
+cp datadog_checks/smartd/check.py /etc/datadog-agent/checks.d/smartd.py
+mkdir -p /etc/datadog-agent/conf.d/smartd.d
+cp datadog_checks/smartd/data/conf.yaml.example /etc/datadog-agent/conf.d/smartd.d/conf.yaml
+```
+
+### Configuration
+
+Edit `/etc/datadog-agent/conf.d/smartd.d/conf.yaml` to configure the check:
+
+```yaml
+init_config:
+
+instances:
+  - smartd_state_dir: /var/lib/smartmontools
+    min_collection_interval: 120
+```
+
+Then [restart the Agent][4].
+
+### Validation
+
+Run the [Agent's status subcommand][5] and look for `smartd` under the Checks section:
+
+```bash
+datadog-agent status
+```
+
+Or run the check directly:
+
+```bash
+datadog-agent check smartd
+```
+
+## Data Collected
+
+### Metrics
+
+See [metadata.csv][6] for a list of metrics provided by this integration.
+
+### Service Checks
+
+**smartd.disk_health**: Returns `OK` if the drive is healthy, `WARNING` if reallocated sectors, pending sectors, or offline uncorrectable counts are non-zero, `CRITICAL` if a normalized attribute value reaches 0.
+
+**smartd.can_read**: Returns `OK` if smartd state files were found and parsed successfully, `CRITICAL` otherwise.
+
+### Events
+
+The smartd integration does not include any events.
+
+## Support
+
+For help, open an issue on the [GitHub repository][7].
+
+[1]: https://en.wikipedia.org/wiki/Self-Monitoring,_Analysis_and_Reporting_Technology
+[2]: https://www.smartmontools.org/wiki/Smartd
+[3]: https://www.smartmontools.org/
+[4]: https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent
+[5]: https://docs.datadoghq.com/agent/guide/agent-commands/#agent-status-and-information
+[6]: https://github.com/DataDog/integrations-extras/blob/master/smartd/metadata.csv
+[7]: https://github.com/DataDog/integrations-extras

datadog_smartd-0.1.0/README.md

@@ -0,0 +1,86 @@
+# smartd
+
+## Overview
+
+This integration monitors [S.M.A.R.T.][1] disk health by reading state files written by the [smartd][2] daemon (part of [smartmontools][3]). It collects key disk health attributes such as temperature, reallocated sectors, power-on hours, and pending sector counts, and reports the overall health status of each drive as a service check.
+
+Unlike other approaches that shell out to `smartctl` (which requires root privileges), this integration reads the state files that `smartd` already maintains, making it work without any privilege escalation.
+
+## Setup
+
+### Prerequisites
+
+- The `smartd` daemon must be running and writing state files (default location: `/var/lib/smartmontools/`).
+- The `dd-agent` user must have read access to the state files (they are typically world-readable with `644` permissions).
+
+### Installation
+
+For development, install the check in the Datadog Agent's Python environment:
+
+```bash
+datadog-agent integration install -e /path/to/smartd
+```
+
+For production, copy the check file and configuration:
+
+```bash
+cp datadog_checks/smartd/check.py /etc/datadog-agent/checks.d/smartd.py
+mkdir -p /etc/datadog-agent/conf.d/smartd.d
+cp datadog_checks/smartd/data/conf.yaml.example /etc/datadog-agent/conf.d/smartd.d/conf.yaml
+```
+
+### Configuration
+
+Edit `/etc/datadog-agent/conf.d/smartd.d/conf.yaml` to configure the check:
+
+```yaml
+init_config:
+
+instances:
+  - smartd_state_dir: /var/lib/smartmontools
+    min_collection_interval: 120
+```
+
+Then [restart the Agent][4].
+
+### Validation
+
+Run the [Agent's status subcommand][5] and look for `smartd` under the Checks section:
+
+```bash
+datadog-agent status
+```
+
+Or run the check directly:
+
+```bash
+datadog-agent check smartd
+```
+
+## Data Collected
+
+### Metrics
+
+See [metadata.csv][6] for a list of metrics provided by this integration.
+
+### Service Checks
+
+**smartd.disk_health**: Returns `OK` if the drive is healthy, `WARNING` if reallocated sectors, pending sectors, or offline uncorrectable counts are non-zero, `CRITICAL` if a normalized attribute value reaches 0.
+
+**smartd.can_read**: Returns `OK` if smartd state files were found and parsed successfully, `CRITICAL` otherwise.
+
+### Events
+
+The smartd integration does not include any events.
+
+## Support
+
+For help, open an issue on the [GitHub repository][7].
+
+[1]: https://en.wikipedia.org/wiki/Self-Monitoring,_Analysis_and_Reporting_Technology
+[2]: https://www.smartmontools.org/wiki/Smartd
+[3]: https://www.smartmontools.org/
+[4]: https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent
+[5]: https://docs.datadoghq.com/agent/guide/agent-commands/#agent-status-and-information
+[6]: https://github.com/DataDog/integrations-extras/blob/master/smartd/metadata.csv
+[7]: https://github.com/DataDog/integrations-extras

datadog_smartd-0.1.0/datadog_checks/smartd/__about__.py

@@ -0,0 +1 @@
+__version__ = '0.1.0'

datadog_smartd-0.1.0/datadog_checks/smartd/__init__.py

@@ -0,0 +1,4 @@
+from .__about__ import __version__
+from .check import SmartdCheck
+
+__all__ = ['__version__', 'SmartdCheck']

datadog_smartd-0.1.0/datadog_checks/smartd/check.py

@@ -0,0 +1,134 @@
+import glob
+import os
+import re
+
+from datadog_checks.base import AgentCheck
+
+FILENAME_PATTERN = re.compile(r'^smartd\.(.+)-([^-]+)\.\w+\.state$')
+
+# SMART attribute ID → metric name mapping
+NAMED_ATTRIBUTES = {
+    1: 'raw_read_error_rate',
+    5: 'reallocated_sectors',
+    9: 'power_on_hours',
+    10: 'spin_retry_count',
+    12: 'power_cycle_count',
+    194: 'temperature',
+    196: 'reallocated_event_count',
+    197: 'current_pending_sectors',
+    198: 'offline_uncorrectable',
+    199: 'udma_crc_error_count',
+}
+
+# Attributes where non-zero raw values indicate potential problems
+WARNING_ATTRIBUTES = {5, 197, 198}
+
+ATTR_LINE_PATTERN = re.compile(
+    r'^ata-smart-attribute\.(\d+)\.(id|val|worst|raw)\s*=\s*(\d+)$'
+)
+
+
+class SmartdCheck(AgentCheck):
+
+    __NAMESPACE__ = 'smartd'
+
+    def __init__(self, name, init_config, instances):
+        super().__init__(name, init_config, instances)
+        self.state_dir = self.instance.get('smartd_state_dir', '/var/lib/smartmontools')
+        self.file_pattern = self.instance.get('file_pattern', 'smartd.*.state')
+
+    def check(self, _):
+        pattern = os.path.join(self.state_dir, self.file_pattern)
+        state_files = sorted(glob.glob(pattern))
+
+        if not state_files:
+            self.service_check('can_read', AgentCheck.CRITICAL, message='No smartd state files found')
+            self.log.error('No smartd state files found matching %s', pattern)
+            return
+
+        for path in state_files:
+            self._process_state_file(path)
+
+        self.service_check('can_read', AgentCheck.OK)
+
+    def _process_state_file(self, path):
+        filename = os.path.basename(path)
+        match = FILENAME_PATTERN.match(filename)
+        if not match:
+            self.log.warning('Could not parse device info from filename: %s', filename)
+            return
+
+        model = match.group(1)
+        serial = match.group(2)
+        device_tags = ['device_model:{}'.format(model), 'serial_number:{}'.format(serial)]
+        tags = device_tags + self.instance.get('tags', [])
+
+        try:
+            attributes = self._parse_state_file(path)
+        except Exception as e:
+            self.log.error('Failed to parse state file %s: %s', path, e)
+            self.service_check('disk_health', AgentCheck.CRITICAL, tags=tags, message=str(e))
+            return
+
+        health = AgentCheck.OK
+        health_message = None
+
+        for attr_id, attr_data in attributes.items():
+            metric_name = NAMED_ATTRIBUTES.get(attr_id)
+            if metric_name is None:
+                continue
+
+            raw = attr_data.get('raw', 0)
+            val = attr_data.get('val', 0)
+
+            if metric_name == 'temperature':
+                # Temperature is encoded in the lowest byte of the raw value
+                value = raw & 0xFF
+            else:
+                value = raw
+
+            self.gauge(metric_name, value, tags=tags)
+
+            # Health checks
+            if val == 0:
+                health = AgentCheck.CRITICAL
+                health_message = 'Attribute {} normalized value is 0'.format(attr_id)
+            elif attr_id in WARNING_ATTRIBUTES and raw > 0 and health != AgentCheck.CRITICAL:
+                health = AgentCheck.WARNING
+                health_message = 'Attribute {} ({}): raw value {}'.format(
+                    attr_id, metric_name, raw
+                )
+
+        self.service_check('disk_health', health, tags=tags, message=health_message)
+
+    def _parse_state_file(self, path):
+        attributes = {}
+
+        with open(path) as f:
+            for line in f:
+                line = line.strip()
+                match = ATTR_LINE_PATTERN.match(line)
+                if not match:
+                    continue
+
+                idx = int(match.group(1))
+                field = match.group(2)
+                value = int(match.group(3))
+
+                if field == 'id':
+                    attributes.setdefault(idx, {})['id'] = value
+                elif field == 'val':
+                    attributes.setdefault(idx, {})['val'] = value
+                elif field == 'worst':
+                    attributes.setdefault(idx, {})['worst'] = value
+                elif field == 'raw':
+                    attributes.setdefault(idx, {})['raw'] = value
+
+        # Re-key by attribute ID instead of index
+        result = {}
+        for attr_data in attributes.values():
+            attr_id = attr_data.get('id')
+            if attr_id is not None:
+                result[attr_id] = attr_data
+
+        return result

datadog_smartd-0.1.0/datadog_checks/smartd/data/conf.yaml.example

@@ -0,0 +1,33 @@
+## All options defined here are available to all instances.
+#
+init_config:
+
+## Every instance is scheduled independently of the others.
+#
+instances:
+
+  -
+    ## @param smartd_state_dir - string - optional - default: /var/lib/smartmontools
+    ## Path to the directory containing smartd state files.
+    #
+    # smartd_state_dir: /var/lib/smartmontools
+
+    ## @param file_pattern - string - optional - default: smartd.*.state
+    ## Glob pattern to match smartd state files within the state directory.
+    #
+    # file_pattern: "smartd.*.state"
+
+    ## @param tags - list of strings - optional
+    ## A list of tags to attach to every metric and service check emitted by this instance.
+    ##
+    ## Learn more about tagging at https://docs.datadoghq.com/tagging
+    #
+    # tags:
+    #   - <KEY_1>:<VALUE_1>
+    #   - <KEY_2>:<VALUE_2>
+
+    ## @param min_collection_interval - number - optional - default: 120
+    ## This changes the collection interval of the check. For more information, see:
+    ## https://docs.datadoghq.com/developers/write_agent_check/#collection-interval
+    #
+    # min_collection_interval: 120

datadog_smartd-0.1.0/hatch.toml

@@ -0,0 +1,9 @@
+# NOTE: [env.collectors.datadog-checks] is needed in integrations-core/extras
+# but requires the monorepo hatch plugin. Uncomment when contributing upstream.
+# [env.collectors.datadog-checks]
+
+[envs.default]
+e2e-env = false
+
+[[envs.default.matrix]]
+python = ["3.13"]

datadog_smartd-0.1.0/manifest.json

@@ -0,0 +1,47 @@
+{
+  "manifest_version": "2.0.0",
+  "app_id": "smartd",
+  "app_uuid": "38657b7d-a5d3-4a34-b65c-0dc36e23f330",
+  "display_on_public_website": true,
+  "tile": {
+    "overview": "README.md#Overview",
+    "configuration": "README.md#Setup",
+    "support": "README.md#Support",
+    "changelog": "CHANGELOG.md",
+    "description": "Monitor S.M.A.R.T. disk health via smartd state files",
+    "title": "smartd",
+    "media": [],
+    "classifier_tags": [
+      "Supported OS::Linux",
+      "Category::OS & System",
+      "Offering::Integration"
+    ]
+  },
+  "author": {
+    "support_email": "help@datadoghq.com",
+    "name": "Community",
+    "homepage": "https://github.com/DataDog/integrations-extras"
+  },
+  "assets": {
+    "integration": {
+      "source_type_name": "smartd",
+      "configuration": {
+        "spec": "assets/configuration/spec.yaml"
+      },
+      "events": {
+        "creates_events": false
+      },
+      "metrics": {
+        "prefix": "smartd.",
+        "check": "smartd.temperature",
+        "metadata_path": "metadata.csv"
+      },
+      "service_checks": {
+        "metadata_path": "assets/service_checks.json"
+      }
+    },
+    "dashboards": {
+      "smartd Overview": "assets/dashboards/smartd_overview.json"
+    }
+  }
+}

datadog_smartd-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling>=0.11.2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "datadog-smartd"
+description = "The smartd check"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.13"
+keywords = ["datadog", "datadog agent", "datadog check", "smartd", "smart"]
+authors = [{ name = "Community" }]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Monitoring",
+]
+dependencies = ["datadog-checks-base>=37.33.0"]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+deps = []
+
+[project.urls]
+Source = "https://github.com/DataDog/integrations-extras"
+
+[tool.hatch.version]
+path = "datadog_checks/smartd/__about__.py"
+
+[tool.hatch.build.targets.sdist]
+include = ["/datadog_checks", "/tests", "/manifest.json"]
+
+[tool.hatch.build.targets.wheel]
+include = ["/datadog_checks/smartd"]
+dev-mode-dirs = ["."]

datadog_smartd-0.1.0/tests/common.py

@@ -0,0 +1,19 @@
+import os
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+FIXTURE_DIR = os.path.join(HERE, 'fixtures')
+
+INSTANCE = {
+    'smartd_state_dir': FIXTURE_DIR,
+    'file_pattern': 'smartd.*.state',
+}
+
+CHECK_NAME = 'smartd'
+
+HEALTHY_MODEL = 'ACME_DISK4000'
+HEALTHY_SERIAL = 'SN123456789ABC'
+HEALTHY_TAGS = ['device_model:{}'.format(HEALTHY_MODEL), 'serial_number:{}'.format(HEALTHY_SERIAL)]
+
+DEGRADED_MODEL = 'ACME_DISK4000'
+DEGRADED_SERIAL = 'SN987654321XYZ'
+DEGRADED_TAGS = ['device_model:{}'.format(DEGRADED_MODEL), 'serial_number:{}'.format(DEGRADED_SERIAL)]

datadog_smartd-0.1.0/tests/conftest.py

@@ -0,0 +1,15 @@
+import pytest
+
+from datadog_checks.smartd import SmartdCheck
+
+from .common import CHECK_NAME, INSTANCE
+
+
+@pytest.fixture(scope='session')
+def dd_environment():
+    yield INSTANCE
+
+
+@pytest.fixture
+def check():
+    return SmartdCheck(CHECK_NAME, {}, [INSTANCE])

datadog_smartd-0.1.0/tests/fixtures/smartd.ACME_DISK4000-SN123456789ABC.ata.state

@@ -0,0 +1,61 @@
+# smartd state file
+ata-smart-attribute.0.id = 1
+ata-smart-attribute.0.val = 100
+ata-smart-attribute.0.worst = 100
+ata-smart-attribute.1.id = 2
+ata-smart-attribute.1.val = 138
+ata-smart-attribute.1.worst = 138
+ata-smart-attribute.1.raw = 76
+ata-smart-attribute.2.id = 3
+ata-smart-attribute.2.val = 133
+ata-smart-attribute.2.worst = 133
+ata-smart-attribute.2.raw = 38683869672
+ata-smart-attribute.3.id = 4
+ata-smart-attribute.3.val = 100
+ata-smart-attribute.3.worst = 100
+ata-smart-attribute.3.raw = 29
+ata-smart-attribute.4.id = 5
+ata-smart-attribute.4.val = 100
+ata-smart-attribute.4.worst = 100
+ata-smart-attribute.5.id = 7
+ata-smart-attribute.5.val = 100
+ata-smart-attribute.5.worst = 100
+ata-smart-attribute.6.id = 8
+ata-smart-attribute.6.val = 138
+ata-smart-attribute.6.worst = 138
+ata-smart-attribute.6.raw = 27
+ata-smart-attribute.7.id = 9
+ata-smart-attribute.7.val = 87
+ata-smart-attribute.7.worst = 87
+ata-smart-attribute.7.raw = 91000
+ata-smart-attribute.8.id = 10
+ata-smart-attribute.8.val = 100
+ata-smart-attribute.8.worst = 100
+ata-smart-attribute.9.id = 12
+ata-smart-attribute.9.val = 100
+ata-smart-attribute.9.worst = 100
+ata-smart-attribute.9.raw = 29
+ata-smart-attribute.10.id = 192
+ata-smart-attribute.10.val = 100
+ata-smart-attribute.10.worst = 100
+ata-smart-attribute.10.raw = 1168
+ata-smart-attribute.11.id = 193
+ata-smart-attribute.11.val = 100
+ata-smart-attribute.11.worst = 100
+ata-smart-attribute.11.raw = 1168
+ata-smart-attribute.12.id = 194
+ata-smart-attribute.12.val = 162
+ata-smart-attribute.12.worst = 162
+ata-smart-attribute.12.raw = 201864314917
+ata-smart-attribute.13.id = 196
+ata-smart-attribute.13.val = 100
+ata-smart-attribute.13.worst = 100
+ata-smart-attribute.14.id = 197
+ata-smart-attribute.14.val = 100
+ata-smart-attribute.14.worst = 100
+ata-smart-attribute.15.id = 198
+ata-smart-attribute.15.val = 100
+ata-smart-attribute.15.worst = 100
+ata-smart-attribute.16.id = 199
+ata-smart-attribute.16.val = 200
+ata-smart-attribute.16.worst = 200

datadog_smartd-0.1.0/tests/fixtures/smartd.ACME_DISK4000-SN987654321XYZ.ata.state

@@ -0,0 +1,66 @@
+# smartd state file
+ata-smart-attribute.0.id = 1
+ata-smart-attribute.0.val = 98
+ata-smart-attribute.0.worst = 95
+ata-smart-attribute.0.raw = 12
+ata-smart-attribute.1.id = 2
+ata-smart-attribute.1.val = 130
+ata-smart-attribute.1.worst = 130
+ata-smart-attribute.1.raw = 80
+ata-smart-attribute.2.id = 3
+ata-smart-attribute.2.val = 120
+ata-smart-attribute.2.worst = 120
+ata-smart-attribute.2.raw = 42949672960
+ata-smart-attribute.3.id = 4
+ata-smart-attribute.3.val = 100
+ata-smart-attribute.3.worst = 100
+ata-smart-attribute.3.raw = 45
+ata-smart-attribute.4.id = 5
+ata-smart-attribute.4.val = 95
+ata-smart-attribute.4.worst = 95
+ata-smart-attribute.4.raw = 16
+ata-smart-attribute.5.id = 7
+ata-smart-attribute.5.val = 100
+ata-smart-attribute.5.worst = 100
+ata-smart-attribute.6.id = 8
+ata-smart-attribute.6.val = 135
+ata-smart-attribute.6.worst = 135
+ata-smart-attribute.6.raw = 30
+ata-smart-attribute.7.id = 9
+ata-smart-attribute.7.val = 75
+ata-smart-attribute.7.worst = 75
+ata-smart-attribute.7.raw = 105000
+ata-smart-attribute.8.id = 10
+ata-smart-attribute.8.val = 100
+ata-smart-attribute.8.worst = 100
+ata-smart-attribute.9.id = 12
+ata-smart-attribute.9.val = 100
+ata-smart-attribute.9.worst = 100
+ata-smart-attribute.9.raw = 45
+ata-smart-attribute.10.id = 192
+ata-smart-attribute.10.val = 100
+ata-smart-attribute.10.worst = 100
+ata-smart-attribute.10.raw = 2000
+ata-smart-attribute.11.id = 193
+ata-smart-attribute.11.val = 100
+ata-smart-attribute.11.worst = 100
+ata-smart-attribute.11.raw = 2000
+ata-smart-attribute.12.id = 194
+ata-smart-attribute.12.val = 150
+ata-smart-attribute.12.worst = 140
+ata-smart-attribute.12.raw = 201864314921
+ata-smart-attribute.13.id = 196
+ata-smart-attribute.13.val = 95
+ata-smart-attribute.13.worst = 95
+ata-smart-attribute.13.raw = 16
+ata-smart-attribute.14.id = 197
+ata-smart-attribute.14.val = 100
+ata-smart-attribute.14.worst = 100
+ata-smart-attribute.14.raw = 2
+ata-smart-attribute.15.id = 198
+ata-smart-attribute.15.val = 100
+ata-smart-attribute.15.worst = 100
+ata-smart-attribute.16.id = 199
+ata-smart-attribute.16.val = 200
+ata-smart-attribute.16.worst = 200
+ata-smart-attribute.16.raw = 3

datadog_smartd-0.1.0/tests/test_smartd.py

@@ -0,0 +1,132 @@
+import os
+from unittest.mock import patch
+
+import pytest
+
+from datadog_checks.base import AgentCheck
+from datadog_checks.smartd import SmartdCheck
+
+from .common import (
+    CHECK_NAME,
+    DEGRADED_TAGS,
+    FIXTURE_DIR,
+    HEALTHY_TAGS,
+    INSTANCE,
+)
+
+pytestmark = pytest.mark.unit
+
+
+def test_check_healthy_and_degraded(aggregator, dd_run_check):
+    check = SmartdCheck(CHECK_NAME, {}, [INSTANCE])
+    dd_run_check(check)
+
+    # Healthy drive metrics
+    aggregator.assert_metric('smartd.raw_read_error_rate', value=0, tags=HEALTHY_TAGS)
+    aggregator.assert_metric('smartd.reallocated_sectors', value=0, tags=HEALTHY_TAGS)
+    aggregator.assert_metric('smartd.power_on_hours', value=91000, tags=HEALTHY_TAGS)
+    aggregator.assert_metric('smartd.spin_retry_count', value=0, tags=HEALTHY_TAGS)
+    aggregator.assert_metric('smartd.power_cycle_count', value=29, tags=HEALTHY_TAGS)
+    aggregator.assert_metric('smartd.temperature', value=37, tags=HEALTHY_TAGS)
+    aggregator.assert_metric('smartd.reallocated_event_count', value=0, tags=HEALTHY_TAGS)
+    aggregator.assert_metric('smartd.current_pending_sectors', value=0, tags=HEALTHY_TAGS)
+    aggregator.assert_metric('smartd.offline_uncorrectable', value=0, tags=HEALTHY_TAGS)
+    aggregator.assert_metric('smartd.udma_crc_error_count', value=0, tags=HEALTHY_TAGS)
+
+    # Degraded drive metrics
+    aggregator.assert_metric('smartd.reallocated_sectors', value=16, tags=DEGRADED_TAGS)
+    aggregator.assert_metric('smartd.current_pending_sectors', value=2, tags=DEGRADED_TAGS)
+    aggregator.assert_metric('smartd.udma_crc_error_count', value=3, tags=DEGRADED_TAGS)
+    aggregator.assert_metric('smartd.temperature', value=41, tags=DEGRADED_TAGS)
+    aggregator.assert_metric('smartd.power_on_hours', value=105000, tags=DEGRADED_TAGS)
+
+    # Service checks
+    aggregator.assert_service_check('smartd.disk_health', AgentCheck.OK, tags=HEALTHY_TAGS)
+    aggregator.assert_service_check('smartd.disk_health', AgentCheck.WARNING, tags=DEGRADED_TAGS)
+    aggregator.assert_service_check('smartd.can_read', AgentCheck.OK)
+
+    aggregator.assert_all_metrics_covered()
+
+
+def test_check_no_files(aggregator, dd_run_check):
+    instance = {
+        'smartd_state_dir': '/nonexistent/path',
+    }
+    check = SmartdCheck(CHECK_NAME, {}, [instance])
+    dd_run_check(check)
+
+    aggregator.assert_service_check('smartd.can_read', AgentCheck.CRITICAL)
+
+
+def test_check_empty_file(aggregator, dd_run_check, tmp_path):
+    state_file = tmp_path / 'smartd.EMPTY_DRIVE-SERIAL000.ata.state'
+    state_file.write_text('')
+
+    instance = {
+        'smartd_state_dir': str(tmp_path),
+    }
+    check = SmartdCheck(CHECK_NAME, {}, [instance])
+    dd_run_check(check)
+
+    tags = ['device_model:EMPTY_DRIVE', 'serial_number:SERIAL000']
+    aggregator.assert_service_check('smartd.disk_health', AgentCheck.OK, tags=tags)
+    aggregator.assert_service_check('smartd.can_read', AgentCheck.OK)
+
+
+def test_check_malformed_lines(aggregator, dd_run_check, tmp_path):
+    state_file = tmp_path / 'smartd.TEST_DRIVE-SERIAL001.ata.state'
+    state_file.write_text(
+        '# comment line\n'
+        'garbage line\n'
+        'ata-smart-attribute.0.id = 194\n'
+        'ata-smart-attribute.0.val = 160\n'
+        'ata-smart-attribute.0.raw = 201864314917\n'
+        'ata-smart-attribute.0.bad_field = 999\n'
+    )
+
+    instance = {
+        'smartd_state_dir': str(tmp_path),
+    }
+    check = SmartdCheck(CHECK_NAME, {}, [instance])
+    dd_run_check(check)
+
+    tags = ['device_model:TEST_DRIVE', 'serial_number:SERIAL001']
+    aggregator.assert_metric('smartd.temperature', value=37, tags=tags)
+    aggregator.assert_service_check('smartd.disk_health', AgentCheck.OK, tags=tags)
+    aggregator.assert_service_check('smartd.can_read', AgentCheck.OK)
+    aggregator.assert_all_metrics_covered()
+
+
+def test_check_unparseable_filename(aggregator, dd_run_check, tmp_path):
+    state_file = tmp_path / 'smartd.bad-filename.state'
+    state_file.write_text('ata-smart-attribute.0.id = 194\n')
+
+    instance = {
+        'smartd_state_dir': str(tmp_path),
+        'file_pattern': 'smartd.*.state',
+    }
+    check = SmartdCheck(CHECK_NAME, {}, [instance])
+    dd_run_check(check)
+
+    # File is found so can_read is OK, but no metrics emitted for unparseable filename
+    aggregator.assert_service_check('smartd.can_read', AgentCheck.OK)
+
+
+def test_custom_tags(aggregator, dd_run_check, tmp_path):
+    state_file = tmp_path / 'smartd.TAG_DRIVE-SERIAL002.ata.state'
+    state_file.write_text(
+        'ata-smart-attribute.0.id = 194\n'
+        'ata-smart-attribute.0.val = 160\n'
+        'ata-smart-attribute.0.raw = 201864314917\n'
+    )
+
+    instance = {
+        'smartd_state_dir': str(tmp_path),
+        'tags': ['datacenter:us-east', 'rack:42'],
+    }
+    check = SmartdCheck(CHECK_NAME, {}, [instance])
+    dd_run_check(check)
+
+    expected_tags = ['device_model:TAG_DRIVE', 'serial_number:SERIAL002', 'datacenter:us-east', 'rack:42']
+    aggregator.assert_metric('smartd.temperature', value=37, tags=expected_tags)
+    aggregator.assert_all_metrics_covered()