release 1 5 0 (#30)

Author: winor30

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@winor30/mcp-server-datadog",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "MCP server for interacting with Datadog API",
   "repository": {
     "type": "git",

src/tools/rum/tool.ts

@@ -118,39 +118,29 @@ export const createRumToolHandlers = (
     const sessions = new Map<string, Set<string>>()
 
     for (const event of response.data) {
-      if (event.attributes?.attributes) {
-        // Get the group value (default to 'unknown' if not found)
-        let groupValue = 'unknown'
+      if (!event.attributes?.attributes) {
+        continue
+      }
 
-        // Parse the groupBy path (e.g., 'application.id')
-        let current = event.attributes.attributes
-        const groupPath = groupBy.split('.') as Array<
-          keyof typeof event.attributes.attributes
-        >
-        let foundPath = true
-
-        for (const pathPart of groupPath) {
-          if (current[pathPart] !== undefined) {
-            current = current[pathPart] as v2.RUMEventAttributes
-          } else {
-            foundPath = false
-            break
-          }
-        }
+      // Parse the groupBy path (e.g., 'application.id')
+      const groupPath = groupBy.split('.') as Array<
+        keyof typeof event.attributes.attributes
+      >
 
-        if (foundPath) {
-          groupValue = String(current)
-        }
+      const result = getValueByPath(
+        event.attributes.attributes,
+        groupPath.map((path) => String(path)),
+      )
+      const groupValue = result.found ? String(result.value) : 'unknown'
 
-        // Get or create the session set for this group
-        if (!sessions.has(groupValue)) {
-          sessions.set(groupValue, new Set<string>())
-        }
+      // Get or create the session set for this group
+      if (!sessions.has(groupValue)) {
+        sessions.set(groupValue, new Set<string>())
+      }
 
-        // Add the session ID to the set if it exists
-        if (event.attributes.attributes.session?.id) {
-          sessions.get(groupValue)?.add(event.attributes.attributes.session.id)
-        }
+      // Add the session ID to the set if it exists
+      if (event.attributes.attributes.session?.id) {
+        sessions.get(groupValue)?.add(event.attributes.attributes.session.id)
       }
     }
 
@@ -189,34 +179,38 @@ export const createRumToolHandlers = (
     }
 
     // Extract and calculate performance metrics
-    const metrics: Record<string, number[]> = {}
-    metricNames.forEach((name) => {
-      metrics[name] = []
-    })
+    const metrics: Record<string, number[]> = metricNames.reduce(
+      (acc, name) => {
+        acc[name] = []
+        return acc
+      },
+      {} as Record<string, number[]>,
+    )
 
     for (const event of response.data) {
-      if (event.attributes?.attributes) {
-        // Collect each requested metric if it exists
-        for (const metricName of metricNames) {
-          // Handle nested properties like 'view.load_time'
-          const parts = metricName.split('.') as Array<
-            keyof typeof event.attributes.attributes
-          >
-          let value = event.attributes.attributes
-
-          for (let i = 0; i < parts.length; i++) {
-            if (value && value[parts[i]] !== undefined) {
-              value = value[parts[i]]
-            } else {
-              value = {}
-              break
-            }
-          }
+      if (!event.attributes?.attributes) {
+        continue
+      }
 
-          // If we found a numeric value, add it to the metrics
-          if (typeof value === 'number') {
-            metrics[metricName].push(value)
-          }
+      // Collect each requested metric if it exists
+      for (const metricName of metricNames) {
+        // Handle nested properties like 'view.load_time'
+        const metricNameParts = metricName.split('.') as Array<
+          keyof typeof event.attributes.attributes
+        >
+
+        if (event.attributes.attributes == null) {
+          continue
+        }
+
+        const value = metricNameParts.reduce(
+          (acc, part) => (acc ? acc[part] : undefined),
+          event.attributes.attributes,
+        )
+
+        // If we found a numeric value, add it to the metrics
+        if (typeof value === 'number') {
+          metrics[metricName].push(value)
         }
       }
     }
@@ -225,21 +219,26 @@ export const createRumToolHandlers = (
     const results: Record<
       string,
       { avg: number; min: number; max: number; count: number }
-    > = {}
-
-    for (const [name, values] of Object.entries(metrics)) {
-      if (values.length > 0) {
-        const sum = values.reduce((a, b) => a + b, 0)
-        results[name] = {
-          avg: sum / values.length,
-          min: Math.min(...values),
-          max: Math.max(...values),
-          count: values.length,
+    > = Object.entries(metrics).reduce(
+      (acc, [name, values]) => {
+        if (values.length > 0) {
+          const sum = values.reduce((a, b) => a + b, 0)
+          acc[name] = {
+            avg: sum / values.length,
+            min: Math.min(...values),
+            max: Math.max(...values),
+            count: values.length,
+          }
+        } else {
+          acc[name] = { avg: 0, min: 0, max: 0, count: 0 }
         }
-      } else {
-        results[name] = { avg: 0, min: 0, max: 0, count: 0 }
-      }
-    }
+        return acc
+      },
+      {} as Record<
+        string,
+        { avg: number; min: number; max: number; count: number }
+      >,
+    )
 
     return {
       content: [
@@ -276,3 +275,27 @@ export const createRumToolHandlers = (
     }
   },
 })
+
+// Get the group value using a recursive function approach
+const getValueByPath = (
+  obj: Record<string, unknown>,
+  path: string[],
+  index = 0,
+): { value: unknown; found: boolean } => {
+  if (index >= path.length) {
+    return { value: obj, found: true }
+  }
+
+  const key = path[index]
+  const typedObj = obj as Record<string, unknown>
+
+  if (typedObj[key] === undefined) {
+    return { value: null, found: false }
+  }
+
+  return getValueByPath(
+    typedObj[key] as Record<string, unknown>,
+    path,
+    index + 1,
+  )
+}