Add initialization health event to SQLServer (DataDog#21868)

* Add initialization health event to SQLServer

* Changelog

* Bump base version

* Base event

* Tags

* Fix timestamp

Author: sethsamuel

sqlserver/changelog.d/21868.added

@@ -0,0 +1 @@
+Add DBM agent health events to SQLServer. Events include basic initialization check, unhandled error, and missed collection.

sqlserver/datadog_checks/sqlserver/config.py

@@ -2,6 +2,7 @@
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
 
+import copy
 import json
 import re
 
@@ -274,3 +275,12 @@ def _build_database_metrics_configs(self, instance):
                 if value is not None:
                     config[key] = value
         return configurable_metrics
+
+
+def sanitize(config: dict) -> dict:
+    """
+    Sanitize the config to remove sensitive information.
+    """
+    sanitized = copy.deepcopy(config)
+    sanitized['password'] = '***' if sanitized.get('password') else None
+    return sanitized

sqlserver/datadog_checks/sqlserver/health.py

@@ -0,0 +1,64 @@
+# (C) Datadog, Inc. 2025-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from datadog_checks.sqlserver import SqlServer
+
+from enum import Enum
+
+from datadog_checks.base.utils.db.health import Health, HealthEvent, HealthStatus
+
+
+class SqlServerHealthEvent(Enum):
+    """
+    Enum representing the health events for SqlServer monitoring.
+    """
+
+    EXPLAIN_PLAN_ERROR = 'explain_plan_error'
+
+
+class SqlServerHealth(Health):
+    def __init__(self, check: SqlServer):
+        # type: (SqlServer) -> None
+        """
+        Initialize the SqlServerHealth instance.
+
+        :param check: SqlServer
+            The check instance that will be used to submit health events.
+        """
+        super().__init__(check)
+        self.check = check
+
+    def submit_health_event(
+        self,
+        name: HealthEvent | SqlServerHealthEvent,
+        status: HealthStatus,
+        tags: list[str] = None,
+        data: dict = None,
+        **kwargs,
+    ):
+        """
+        Submit a health event to the aggregator.
+
+        :param name: SqlServerHealthEvent
+            The name of the health event.
+        :param status: HealthStatus
+            The health status to submit.
+        :param data: A dictionary to be submitted as `data`. Must be JSON serializable.
+        """
+        super().submit_health_event(
+            name=name,
+            status=status,
+            # If we have an error parsing the config we may not have tags yet
+            tags=(self.check.tags if hasattr(self.check, 'tags') else []) + (tags or []),
+            data={
+                "database_instance": self.check.database_identifier,
+                "ddagenthostname": self.check.agent_hostname,
+                **(data or {}),
+            },
+            **kwargs,
+        )

sqlserver/datadog_checks/sqlserver/sqlserver.py

@@ -11,8 +11,10 @@
 from cachetools import TTLCache
 
 from datadog_checks.base import AgentCheck
+from datadog_checks.base.checks.db import DatabaseCheck
 from datadog_checks.base.config import is_affirmative
 from datadog_checks.base.utils.db import QueryExecutor, QueryManager
+from datadog_checks.base.utils.db.health import HealthEvent, HealthStatus
 from datadog_checks.base.utils.db.utils import (
     TagManager,
     default_json_event_encoding,
@@ -49,15 +51,18 @@
     SQLServerXESessionMetrics,
 )
 from datadog_checks.sqlserver.deadlocks import Deadlocks
+from datadog_checks.sqlserver.health import SqlServerHealth
 from datadog_checks.sqlserver.metadata import SqlserverMetadata
 from datadog_checks.sqlserver.schemas import Schemas
 from datadog_checks.sqlserver.statements import SqlserverStatementMetrics
 from datadog_checks.sqlserver.stored_procedures import SqlserverProcedureMetrics
 from datadog_checks.sqlserver.utils import Database, construct_use_statement, parse_sqlserver_major_version
 from datadog_checks.sqlserver.xe_collection.registry import get_xe_session_handlers
 
+from .config import sanitize
+
 try:
-    import datadog_agent
+    import datadog_agent  # type: ignore
 except ImportError:
     from datadog_checks.base.stubs import datadog_agent
 
@@ -116,14 +121,16 @@
 set_default_driver_conf()
 
 
-class SQLServer(AgentCheck):
+class SQLServer(DatabaseCheck):
     __NAMESPACE__ = "sqlserver"
 
     HA_SUPPORTED = True
 
     def __init__(self, name, init_config, instances):
         super(SQLServer, self).__init__(name, init_config, instances)
 
+        self.health = SqlServerHealth(self)
+
         self.static_info_cache = TTLCache(
             maxsize=100,
             # cache these for a full day
@@ -141,6 +148,8 @@ def __init__(self, name, init_config, instances):
         self.do_check = True
 
         self._config = SQLServerConfig(self.init_config, self.instance, self.log)
+        self._initialized_at = int(time.time() * 1000)
+
         self.cloud_metadata = self._config.cloud_metadata
         self.tag_manager = TagManager(normalizer=lambda tag: self.normalize_tag(tag).lower())
         self.tag_manager.set_tags_from_list(self._config.tags, replace=True)  # Initialize from static config tags
@@ -183,6 +192,8 @@ def __init__(self, name, init_config, instances):
 
         self._schemas = Schemas(self, self._config)
 
+        self._submit_initialization_health_event()
+
     def initialize_xe_session_handlers(self):
         """Initialize the XE session handlers without starting them"""
         # Initialize XE session handlers if not already initialized
@@ -218,6 +229,22 @@ def config_checks(self):
                 "Autodiscovery is disabled, autodiscovery_include and autodiscovery_exclude will be ignored"
             )
 
+    def _submit_initialization_health_event(self):
+        try:
+            # Handle the config validation result after we've set tags so those tags are included in the health event
+            # TODO: Validate the config once it has been refactored
+            self.health.submit_health_event(
+                name=HealthEvent.INITIALIZATION,
+                status=HealthStatus.OK,
+                cooldown_time=60 * 60 * 6,  # 6 hours
+                data={
+                    "initialized_at": self._initialized_at,
+                    "instance": sanitize(self.instance),
+                },
+            )
+        except Exception as e:
+            self.log.error("Error submitting health event for initialization: %s", e)
+
     def _new_query_executor(self, queries, executor, extra_tags=None, track_operation_time=False):
         tags = self.tag_manager.get_tags() + (extra_tags or [])
         return QueryExecutor(
@@ -299,6 +326,10 @@ def port(self):
     def resolve_db_host(self):
         return agent_host_resolver(self.host)
 
+    @property
+    def tags(self):
+        return self.tag_manager.get_tags()
+
     @property
     def reported_hostname(self):
         # type: () -> str
@@ -821,6 +852,8 @@ def _check_database_conns(self):
             self._check_connections_by_use_db()
 
     def check(self, _):
+        self._submit_initialization_health_event()
+
         if self.do_check:
             self.load_static_information()
             # configure custom queries for the check

sqlserver/pyproject.toml

@@ -28,7 +28,7 @@ classifiers = [
     "Private :: Do Not Upload",
 ]
 dependencies = [
-    "datadog-checks-base>=37.21.0",
+    "datadog-checks-base>=37.22.1",
 ]
 dynamic = [
     "version",