public/grafana
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Graphite: Backend querying improvements (#111549)

Browse Source
This commit is contained in:
Andreas Christou
2025-10-01 15:04:21 +02:00
committed by GitHub
parent bb7358be29
commit ed7163a26f
12 changed files with 1014 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/tsdb/graphite/query_test.go
+446 -2
View File
@@ -3,6 +3,7 @@ package graphite
import (
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"net/http/httptest"
@@ -14,6 +15,7 @@ import (
"github.com/grafana/grafana-plugin-sdk-go/backend"
"github.com/grafana/grafana-plugin-sdk-go/backend/httpclient"
"github.com/grafana/grafana-plugin-sdk-go/data"
"github.com/grafana/grafana-plugin-sdk-go/experimental"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.opentelemetry.io/otel/trace/noop"
@@ -99,7 +101,7 @@ func TestProcessQuery(t *testing.T) {
Queries: queries,
})
assert.NoError(t, err)
expectedResponse := backend.ErrDataResponseWithSource(400, backend.ErrorSourceDownstream, "no query target found for the alert rule")
expectedResponse := backend.ErrDataResponseWithSource(400, backend.ErrorSourceDownstream, "no query target found")
assert.Equal(t, expectedResponse, rsp.Responses["A"])
})
@@ -115,13 +117,14 @@ func TestProcessQuery(t *testing.T) {
t.Run("QueryData happy path with service provider and plugin context", func(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
_, _ = w.Write([]byte(`[
_, err := w.Write([]byte(`[
{
"target": "target A",
"tags": { "fooTag": "fooValue", "barTag": "barValue", "int": 100, "float": 3.14 },
"datapoints": [[50, 1], [null, 2], [100, 3]]
}
]`))
require.NoError(t, err)
}))
t.Cleanup(server.Close)
@@ -259,3 +262,444 @@ func TestFixIntervalFormat(t *testing.T) {
})
}
}
func TestRunQueryE2E(t *testing.T) {
tests := []struct {
name string
serverResponse string
serverStatus int
queries []backend.DataQuery
expectError bool
errorContains string
multipleTargets map[string]string
}{
{
name: "successful single query with data",
serverStatus: 200,
serverResponse: `[
{
"target": "stats.counters.web.hits",
"datapoints": [[100, 1609459200], [150, 1609459260], [120, 1609459320]]
}
]`,
queries: []backend.DataQuery{
{
RefID: "A",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459320, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{
"target": "stats.counters.web.hits"
}`),
},
},
expectError: false,
},
{
name: "successful single query with null values",
serverStatus: 200,
serverResponse: `[
{
"target": "stats.counters.web.hits",
"datapoints": [[100, 1609459200], [null, 1609459260], [120, 1609459320]]
}
]`,
queries: []backend.DataQuery{
{
RefID: "A",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459320, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{
"target": "stats.counters.web.hits"
}`),
},
},
expectError: false,
},
{
name: "successful single query with tags",
serverStatus: 200,
serverResponse: `[
{
"target": "stats.counters.web.hits",
"tags": {
"host": "server1",
"environment": "production",
"port": 8080,
"rate": 99.5
},
"datapoints": [[100, 1609459200], [150, 1609459260]]
}
]`,
queries: []backend.DataQuery{
{
RefID: "A",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459260, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{
"target": "stats.counters.web.hits"
}`),
},
},
expectError: false,
},
{
name: "successful multiple queries",
serverStatus: 200,
multipleTargets: map[string]string{
"stats.counters.web.hits": `[
{
"target": "stats.counters.web.hits",
"datapoints": [[100, 1609459200], [150, 1609459260]]
}
]`,
"stats.counters.api.calls": `[
{
"target": "stats.counters.api.calls",
"datapoints": [[50, 1609459200], [75, 1609459260]]
}
]`,
},
queries: []backend.DataQuery{
{
RefID: "A",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459260, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{
"target": "stats.counters.web.hits"
}`),
},
{
RefID: "B",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459260, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{
"target": "stats.counters.api.calls"
}`),
},
},
expectError: false,
},
{
name: "query with empty target",
serverStatus: 200,
serverResponse: `[]`,
queries: []backend.DataQuery{
{
RefID: "A",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459260, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{
"target": ""
}`),
},
},
expectError: true,
errorContains: "no query target found",
},
{
name: "mixed queries - some empty, some valid",
serverStatus: 200,
serverResponse: `[
{
"target": "stats.counters.web.hits",
"datapoints": [[100, 1609459200], [150, 1609459260]]
}
]`,
queries: []backend.DataQuery{
{
RefID: "A",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459260, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{
"target": ""
}`),
},
{
RefID: "B",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459260, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{
"target": "stats.counters.web.hits"
}`),
},
},
expectError: false,
},
{
name: "server error response",
serverStatus: 500,
serverResponse: `{"error": "Internal server error"}`,
queries: []backend.DataQuery{
{
RefID: "A",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459260, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{
"target": "stats.counters.web.hits"
}`),
},
},
expectError: true,
errorContains: "request failed with error",
},
{
name: "server error response with HTML content",
serverStatus: 500,
serverResponse: `<body>
<h1>Internal Server Error</h1>
<p>The server encountered an unexpected condition that prevented it from fulfilling the request.</p>
<div>Error: Invalid metric path &#39;stats.invalid.metric&#39;</div>
Error: Target not found
</body>`,
queries: []backend.DataQuery{
{
RefID: "A",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459260, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{
"target": "stats.invalid.metric"
}`),
},
},
expectError: true,
errorContains: "Error: Target not found", // Should parse HTML and extract the last meaningful line
},
{
name: "malformed JSON response",
serverStatus: 200,
serverResponse: `[{invalid json}]`,
queries: []backend.DataQuery{
{
RefID: "A",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459260, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{
"target": "stats.counters.web.hits"
}`),
},
},
expectError: true,
},
{
name: "invalid query JSON",
serverStatus: 200,
serverResponse: `[]`,
queries: []backend.DataQuery{
{
RefID: "A",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459260, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{invalid json}`),
},
},
expectError: true,
errorContains: "failed to decode the Graphite query",
},
{
name: "interval format transformation",
serverStatus: 200,
serverResponse: `[
{
"target": "hitcount(stats.counters.web.hits, '1min')",
"datapoints": [[100, 1609459200], [150, 1609459260]]
}
]`,
queries: []backend.DataQuery{
{
RefID: "A",
TimeRange: backend.TimeRange{
From: time.Unix(1609459200, 0),
To: time.Unix(1609459260, 0),
},
MaxDataPoints: 1000,
JSON: []byte(`{
"target": "hitcount(stats.counters.web.hits, '1m')"
}`),
},
},
expectError: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
testName := strings.ReplaceAll(tt.name, " ", "_")
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
err := r.ParseForm()
require.NoError(t, err)
// Choose response based on target for multiple queries
response := tt.serverResponse
if tt.multipleTargets != nil {
target := r.FormValue("target")
if targetResponse, ok := tt.multipleTargets[target]; ok {
response = targetResponse
}
}
if !strings.Contains(tt.name, "empty target") {
assert.NotEmpty(t, r.FormValue("target"))
}
w.WriteHeader(tt.serverStatus)
_, err = w.Write([]byte(response))
require.NoError(t, err)
}))
defer server.Close()
dsInfo := &datasourceInfo{
Id: 1,
URL: server.URL,
HTTPClient: &http.Client{},
}
service := &Service{
logger: backend.Logger,
}
req := &backend.QueryDataRequest{
PluginContext: backend.PluginContext{
DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{
ID: 1,
URL: server.URL,
},
OrgID: 1,
},
Queries: tt.queries,
}
result, err := service.RunQuery(context.Background(), req, dsInfo)
if tt.expectError {
if err != nil {
if tt.errorContains != "" {
assert.Contains(t, err.Error(), tt.errorContains)
}
} else {
require.NotNil(t, result)
found := false
for _, resp := range result.Responses {
if resp.Error != nil {
found = true
if tt.errorContains != "" {
assert.Contains(t, resp.Error.Error(), tt.errorContains)
}
break
}
}
assert.True(t, found, "Expected error but none found")
}
} else {
assert.NoError(t, err)
require.NotNil(t, result)
for refID, resp := range result.Responses {
experimental.CheckGoldenJSONResponse(t, "testdata", fmt.Sprintf("%s-RefID-%s.golden", testName, refID), &resp, false)
}
}
})
}
}
func TestParseGraphiteError(t *testing.T) {
tests := []struct {
name string
status int
body string
expected string
}{
{
name: "simple text error",
status: 400,
body: "Bad request: invalid target",
expected: "Bad request: invalid target",
},
{
name: "JSON error",
status: 400,
body: `{"error": "Invalid target format"}`,
expected: `{"error": "Invalid target format"}`,
},
{
name: "HTML error",
status: 500,
body: `<body><h1>Internal Server Error</h1><p>Target not found</p></body>`,
expected: "Internal Server Error\nTarget not found",
},
{
name: "complex HTML error",
status: 500,
body: `<body>
<h1>Internal Server Error</h1>
<p>The server encountered an unexpected condition that prevented it from fulfilling the request.</p>
<div>Error: Invalid metric path &#39;stats.invalid.metric&#39;</div>
Final error message here
</body>`,
expected: "Internal Server Error\nThe server encountered an unexpected condition that prevented it from fulfilling the request.\nError: Invalid metric path 'stats.invalid.metric'\nFinal error message here",
},
{
name: "HTML error with unicode",
status: 500,
body: `<body><p>Error: Invalid path &#x27;test&#x27; and &#x22;value&#x22;</p></body>`,
expected: "Error: Invalid path 'test' and \"value\"",
},
{
name: "HTML with whitespace and newlines",
status: 500,
body: `<body>
<h1>Error</h1>
<p>Something went wrong</p>
Critical failure occurred
</body>`,
expected: "Error\nSomething went wrong\nCritical failure occurred",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := parseGraphiteError(tt.status, tt.body)
assert.Equal(t, tt.expected, result)
})
}
}