fix(parsers): enable proper XPath array element access in JSON parser

The xpath_json parser previously failed to correctly parse JSON array
elements using XPath expressions like //array[1]/field. This was because
the underlying jsonquery library treats arrays as single container nodes
with unnamed children, making it impossible to index into arrays directly.

This change modifies the JSON document handler to:
- Convert JSON to CBOR format internally
- Use cborquery for parsing, which correctly handles array elements as
  named siblings that can be indexed with XPath expressions

The fix enables users to access JSON array elements using intuitive XPath
syntax like //nvme_namespaces[1]/capacity/bytes instead of requiring the
workaround //*[local-name()='nvme_namespaces']/*[1]/capacity/bytes.

Note: This is a breaking change for some XPath query patterns:
- Array selection: Use //array instead of //array/* to select elements
- String representation of objects/arrays differs from JSON format

Fixes #18145

Signed-off-by: majiayu000 <1835304752@qq.com>

Author: majiayu000

plugins/parsers/xpath/json_document.go

@@ -1,23 +1,38 @@
 package xpath
 
 import (
-	"reflect"
+	"bytes"
+	"encoding/json"
+	"fmt"
 	"strconv"
-	"strings"
 
-	"github.com/antchfx/jsonquery"
 	path "github.com/antchfx/xpath"
+	"github.com/fxamacker/cbor/v2"
+	"github.com/srebhan/cborquery"
 )
 
 type jsonDocument struct{}
 
 func (*jsonDocument) Parse(buf []byte) (dataNode, error) {
-	return jsonquery.Parse(strings.NewReader(string(buf)))
+	// First parse JSON to an interface{}
+	var data interface{}
+	if err := json.Unmarshal(buf, &data); err != nil {
+		return nil, fmt.Errorf("failed to parse JSON: %w", err)
+	}
+
+	// Convert to CBOR to leverage cborquery's correct array handling
+	cborData, err := cbor.Marshal(data)
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert JSON to CBOR: %w", err)
+	}
+
+	// Parse with cborquery which handles arrays correctly
+	return cborquery.Parse(bytes.NewReader(cborData))
 }
 
 func (*jsonDocument) QueryAll(node dataNode, expr string) ([]dataNode, error) {
 	// If this panics it's a programming error as we changed the document type while processing
-	native, err := jsonquery.QueryAll(node.(*jsonquery.Node), expr)
+	native, err := cborquery.QueryAll(node.(*cborquery.Node), expr)
 	if err != nil {
 		return nil, err
 	}
@@ -31,15 +46,15 @@ func (*jsonDocument) QueryAll(node dataNode, expr string) ([]dataNode, error) {
 
 func (*jsonDocument) CreateXPathNavigator(node dataNode) path.NodeNavigator {
 	// If this panics it's a programming error as we changed the document type while processing
-	return jsonquery.CreateXPathNavigator(node.(*jsonquery.Node))
+	return cborquery.CreateXPathNavigator(node.(*cborquery.Node))
 }
 
 func (d *jsonDocument) GetNodePath(node, relativeTo dataNode, sep string) string {
 	names := make([]string, 0)
 
 	// If these panic it's a programming error as we changed the document type while processing
-	nativeNode := node.(*jsonquery.Node)
-	nativeRelativeTo := relativeTo.(*jsonquery.Node)
+	nativeNode := node.(*cborquery.Node)
+	nativeRelativeTo := relativeTo.(*cborquery.Node)
 
 	// Climb up the tree and collect the node names
 	n := nativeNode.Parent
@@ -64,40 +79,41 @@ func (d *jsonDocument) GetNodePath(node, relativeTo dataNode, sep string) string
 
 func (d *jsonDocument) GetNodeName(node dataNode, sep string, withParent bool) string {
 	// If this panics it's a programming error as we changed the document type while processing
-	nativeNode := node.(*jsonquery.Node)
+	nativeNode := node.(*cborquery.Node)
 
-	name := nativeNode.Data
+	name := nativeNode.Name
 
-	// Check if the node is part of an array. If so, determine the index and
-	// concatenate the parent name and the index.
-	kind := reflect.Invalid
-	if nativeNode.Parent != nil && nativeNode.Parent.Value() != nil {
-		kind = reflect.TypeOf(nativeNode.Parent.Value()).Kind()
-	}
-
-	switch kind {
-	case reflect.Slice, reflect.Array:
-		// Determine the index for array elements
-		if name == "" && nativeNode.Parent != nil && withParent {
-			name = nativeNode.Parent.Data + sep
+	// In cborquery, array elements appear as siblings with the same name.
+	// Check if this node is part of an array by looking for siblings with the same name.
+	if nativeNode.Parent != nil && name != "" {
+		idx, count := d.siblingIndex(nativeNode)
+		if count > 1 {
+			// This is an array element, append the index
+			return name + sep + strconv.Itoa(idx)
 		}
-		return name + d.index(nativeNode)
 	}
 
 	return name
 }
 
 func (*jsonDocument) OutputXML(node dataNode) string {
-	native := node.(*jsonquery.Node)
+	native := node.(*cborquery.Node)
 	return native.OutputXML()
 }
 
-func (*jsonDocument) index(node *jsonquery.Node) string {
-	idx := 0
-
-	for n := node; n.PrevSibling != nil; n = n.PrevSibling {
-		idx++
+func (*jsonDocument) siblingIndex(node *cborquery.Node) (idx, count int) {
+	if node.Parent == nil {
+		return 0, 1
 	}
 
-	return strconv.Itoa(idx)
+	// Count siblings with the same name and find our index among them
+	for sibling := node.Parent.FirstChild; sibling != nil; sibling = sibling.NextSibling {
+		if sibling.Name == node.Name {
+			if sibling == node {
+				idx = count
+			}
+			count++
+		}
+	}
+	return idx, count
 }

plugins/parsers/xpath/msgpack_document.go

@@ -2,23 +2,39 @@ package xpath
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
 
-	"github.com/antchfx/jsonquery"
 	path "github.com/antchfx/xpath"
+	"github.com/fxamacker/cbor/v2"
+	"github.com/srebhan/cborquery"
 	"github.com/tinylib/msgp/msgp"
 )
 
 type msgpackDocument jsonDocument
 
 func (*msgpackDocument) Parse(buf []byte) (dataNode, error) {
-	var json bytes.Buffer
+	var jsonBuf bytes.Buffer
 
-	// Unmarshal the message-pack binary message to JSON and proceed with the jsonquery class
-	if _, err := msgp.UnmarshalAsJSON(&json, buf); err != nil {
+	// Unmarshal the message-pack binary message to JSON
+	if _, err := msgp.UnmarshalAsJSON(&jsonBuf, buf); err != nil {
 		return nil, fmt.Errorf("unmarshalling to json failed: %w", err)
 	}
-	return jsonquery.Parse(&json)
+
+	// Parse JSON to interface{}
+	var data interface{}
+	if err := json.Unmarshal(jsonBuf.Bytes(), &data); err != nil {
+		return nil, fmt.Errorf("failed to parse JSON: %w", err)
+	}
+
+	// Convert to CBOR to leverage cborquery's correct array handling
+	cborData, err := cbor.Marshal(data)
+	if err != nil {
+		return nil, fmt.Errorf("failed to convert JSON to CBOR: %w", err)
+	}
+
+	// Parse with cborquery which handles arrays correctly
+	return cborquery.Parse(bytes.NewReader(cborData))
 }
 
 func (d *msgpackDocument) QueryAll(node dataNode, expr string) ([]dataNode, error) {

plugins/parsers/xpath/parser.go

@@ -11,7 +11,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/antchfx/jsonquery"
 	path "github.com/antchfx/xpath"
 	"github.com/srebhan/cborquery"
 	"github.com/srebhan/protobufquery"
@@ -493,8 +492,6 @@ func (p *Parser) executeQuery(doc, selected dataNode, query string) (r interface
 			switch nn := current.(type) {
 			case *cborquery.NodeNavigator:
 				return nn.GetValue(), nil
-			case *jsonquery.NodeNavigator:
-				return nn.GetValue(), nil
 			case *protobufquery.NodeNavigator:
 				return nn.GetValue(), nil
 			}
@@ -562,10 +559,18 @@ func (p *Parser) constructFieldName(root, node dataNode, name string, expand boo
 
 	// In case the name is empty we should determine the current node's name.
 	// This involves array index expansion in case the parent of the node is
-	// and array. If we expanded here, we should skip our parent as this is
-	// already encoded in the name
+	// an array. If we expanded here, we should skip our parent as this is
+	// already encoded in the name.
 	if name == "" {
 		name = p.document.GetNodeName(node, "_", !expand)
+	} else {
+		// For non-empty names, check if this is an array element and append index.
+		// GetNodeName returns the name with array index for array elements.
+		nodeName := p.document.GetNodeName(node, "_", false)
+		if nodeName != name && strings.Contains(nodeName, name+"_") {
+			// The node name includes an array index (e.g., "cpus_0" vs "cpus")
+			name = nodeName
+		}
 	}
 
 	// If name expansion is requested, construct a path between the current

plugins/parsers/xpath/parser_test.go

@@ -1604,7 +1604,7 @@ const benchmarkDataJSON = `
 `
 
 var benchmarkConfigJSON = Config{
-	Selection: "data/*",
+	Selection: "//data",
 	Tags: map[string]string{
 		"tags_host":     "tags_host",
 		"tags_sdkver":   "tags_sdkver",

plugins/parsers/xpath/testcases/json_array_indexing/expected.out

@@ -0,0 +1 @@
+nvme,device=/dev/nvme1,model_name=Samsung\ SSD,serial_number=ABC123 ns1_capacity=960197124096i,ns1_id=1i,ns1_utilization=86638583808i,ns2_capacity=500107862016i,ns2_id=2i

plugins/parsers/xpath/testcases/json_array_indexing/telegraf.conf

@@ -0,0 +1,21 @@
+[[inputs.file]]
+  files = ["./testcases/json_array_indexing/test.json"]
+  data_format = "xpath_json"
+
+  xpath_native_types = true
+
+  [[inputs.file.xpath]]
+    metric_name = "'nvme'"
+
+    [inputs.file.xpath.tags]
+      device = "string(/device/name)"
+      model_name = "string(/model_name)"
+      serial_number = "string(/serial_number)"
+
+    [inputs.file.xpath.fields_int]
+      # Test accessing array elements by index - this is the fix for issue #18145
+      ns1_id = "number(//nvme_namespaces[1]/id)"
+      ns1_capacity = "number(//nvme_namespaces[1]/capacity/bytes)"
+      ns1_utilization = "number(//nvme_namespaces[1]/utilization/bytes)"
+      ns2_id = "number(//nvme_namespaces[2]/id)"
+      ns2_capacity = "number(//nvme_namespaces[2]/capacity/bytes)"

plugins/parsers/xpath/testcases/json_array_indexing/test.json

@@ -0,0 +1,27 @@
+{
+  "device": {
+    "name": "/dev/nvme1"
+  },
+  "model_name": "Samsung SSD",
+  "serial_number": "ABC123",
+  "nvme_namespaces": [
+    {
+      "id": 1,
+      "capacity": {
+        "bytes": 960197124096
+      },
+      "utilization": {
+        "bytes": 86638583808
+      }
+    },
+    {
+      "id": 2,
+      "capacity": {
+        "bytes": 500107862016
+      },
+      "utilization": {
+        "bytes": 42949672960
+      }
+    }
+  ]
+}

plugins/parsers/xpath/testcases/json_explicit_precedence/expected.out

@@ -1 +1 @@
-foo a="a string",b=3.1415,c=true,d="{\"d1\":1,\"d2\":\"foo\",\"d3\":true,\"d4\":null}",e="[\"master\",42,true]",timestamp=1690193829 1690193829000000000
+foo a="a string",b=3.1415,c=true,d="map[d1:1 d2:foo d3:true d4:<nil>]",e="master",e_0="master",e_1=42,e_2=true,timestamp=1690193829 1690193829000000000

plugins/parsers/xpath/testcases/json_native_nonnested/expected.out

@@ -1 +1 @@
-foo a="a string",b=3.1415,c=true,d="map[d1:1 d2:foo d3:true d4:<nil>]",e="[master 42 true]",timestamp=1690193829 1690193829000000000
+foo a="a string",b=3.1415,c=true,d="map[d1:1 d2:foo d3:true d4:<nil>]",e_0="master",e_1=42,e_2=true,timestamp=1690193829 1690193829000000000

plugins/parsers/xpath/testcases/json_string_representation/expected.out

@@ -1 +1 @@
-foo a="a string",b="3.1415",c="true",d="{\"d1\":1,\"d2\":\"foo\",\"d3\":true,\"d4\":null}",e="[\"master\",42,true]",timestamp="1690193829" 1690193829000000000
+foo a="a string",b="3.1415",c="true",d="map[d1:1 d2:foo d3:true d4:<nil>]",e_0="master",e_1="42",e_2="true",timestamp="1.690193829e+09" 1690193829000000000