Merge pull request #853 from Altinity/fix_grafana_reject

Fix grafana rejects

Author: Slach

.dockerignore

@@ -7,3 +7,6 @@ instrumented
 node_modules
 venv
 coverage
+.claude*
+.qwen*
+.opencode*

pkg/client.go

@@ -3,8 +3,6 @@ package main
 import (
 	"bytes"
 	"context"
-	"crypto/tls"
-	"crypto/x509"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -42,8 +40,6 @@ func (client *ClickHouseClient) Query(ctx context.Context, query string) (*Respo
 		return onErr(fmt.Errorf("unable to parse clickhouse datasource url: %w", err))
 	}
 
-	httpClient := &http.Client{}
-	tlsConfig := &tls.Config{}
 	var req *http.Request
 	if client.settings.UsePost {
 		req, err = http.NewRequest("POST", datasourceUrl.String(), bytes.NewBufferString(query))
@@ -87,60 +83,56 @@ func (client *ClickHouseClient) Query(ctx context.Context, query string) (*Respo
 		}
 	}
 
-	tlsCACert, tlsCACertExists := client.settings.Instance.DecryptedSecureJSONData["tlsCACert"]
-	tlsClientCert, tlsClientCertExists := client.settings.Instance.DecryptedSecureJSONData["tlsClientCert"]
-	tlsClientKey, tlsClientKeyExists := client.settings.Instance.DecryptedSecureJSONData["tlsClientKey"]
-
-	if tlsCACertExists {
-		rootCA := x509.NewCertPool()
-		ok := rootCA.AppendCertsFromPEM([]byte(tlsCACert))
-		if !ok {
-			return onErr(errors.New(fmt.Sprintf("invalid tlsCACert: %s", tlsCACert)))
-		}
-		tlsConfig.RootCAs = rootCA
-	}
-	if tlsClientCertExists != tlsClientKeyExists {
-		return onErr(errors.New("please setup both tlsClientCert and tlsClientKey"))
-	}
-	if tlsClientCertExists && tlsClientKeyExists {
-		clientKeyPair, err := tls.X509KeyPair([]byte(tlsClientCert), []byte(tlsClientKey))
-		if err != nil {
-			return onErr(err)
-		}
-		tlsConfig.Certificates = append(tlsConfig.Certificates, clientKeyPair)
-	}
-	if client.settings.TLSSkipVerify {
-		tlsConfig.InsecureSkipVerify = true
-	}
-
-	httpClient.Transport = &http.Transport{TLSClientConfig: tlsConfig}
 	req = req.WithContext(ctx)
-	resp, err := httpClient.Do(req)
+	if client.settings.HTTPClient == nil {
+		return onErr(errors.New("http client is not initialized"))
+	}
+	resp, err := client.settings.HTTPClient.Do(req)
 	if err != nil {
 		return onErr(err)
 	}
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil {
+			backend.Logger.Warn(fmt.Sprintf("unable to close response body: %v", closeErr))
+		}
+	}()
 
 	var reader io.Reader
+	closeEncodedReader := func() {}
 	switch resp.Header.Get("Content-Encoding") {
 	case "gzip":
-		reader, err = gzip.NewReader(resp.Body)
+		gzipReader, gzipErr := gzip.NewReader(resp.Body)
+		reader = gzipReader
+		err = gzipErr
 		if err != nil {
 			return onErr(fmt.Errorf("error creating GZIP reader: %v", err))
 		}
+		closeEncodedReader = func() {
+			if closeErr := gzipReader.Close(); closeErr != nil {
+				backend.Logger.Warn(fmt.Sprintf("unable to close gzip reader: %v", closeErr))
+			}
+		}
 	case "deflate":
-		reader = flate.NewReader(resp.Body)
+		flateReader := flate.NewReader(resp.Body)
+		reader = flateReader
+		closeEncodedReader = func() {
+			if closeErr := flateReader.Close(); closeErr != nil {
+				backend.Logger.Warn(fmt.Sprintf("unable to close deflate reader: %v", closeErr))
+			}
+		}
 	case "br":
 		reader = brotli.NewReader(resp.Body)
 	case "zstd":
 		decoder, zstdErr := zstd.NewReader(resp.Body)
 		if zstdErr != nil {
 			return onErr(fmt.Errorf("error creating ZSTD reader: %v", zstdErr))
 		}
-		defer decoder.Close()
 		reader = decoder.IOReadCloser()
+		closeEncodedReader = decoder.Close
 	default:
 		reader = resp.Body
 	}
+	defer closeEncodedReader()
 
 	body, err := io.ReadAll(reader)
 	if err != nil {

pkg/datasource_settings.go

@@ -4,9 +4,11 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"net/http"
 	"strings"
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana-plugin-sdk-go/backend/httpclient"
 	"github.com/grafana/grafana-plugin-sdk-go/backend/instancemgmt"
 )
 
@@ -25,6 +27,7 @@ type DatasourceSettings struct {
 	TLSSkipVerify                 bool   `json:"tlsSkipVerify"`
 
 	CustomHeaders map[string]string `json:"-,omitempty"`
+	HTTPClient    *http.Client      `json:"-"`
 }
 
 func NewDatasourceSettings(ctx context.Context, settings backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) {
@@ -57,8 +60,20 @@ func NewDatasourceSettings(ctx context.Context, settings backend.DataSourceInsta
 	}
 
 	dsSettings.Instance = settings
+	httpClientOptions, err := settings.HTTPClientOptions(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("unable to build http client options: %w", err)
+	}
+	dsSettings.HTTPClient, err = httpclient.New(httpClientOptions)
+	if err != nil {
+		return nil, fmt.Errorf("unable to create http client: %w", err)
+	}
 
 	return &dsSettings, nil
 }
 
-func (s *DatasourceSettings) Dispose() {}
+func (s *DatasourceSettings) Dispose() {
+	if s.HTTPClient != nil {
+		s.HTTPClient.CloseIdleConnections()
+	}
+}

src/views/QueryEditor/QueryEditor.css

@@ -10,7 +10,6 @@ import {useQueryState} from './hooks/useQueryState';
 import {useFormattedData} from './hooks/useFormattedData';
 import {useAutocompleteData} from './hooks/useAutocompletionData';
 import {initializeQueryDefaults, initializeQueryDefaultsForVariables} from './helpers/initializeQueryDefaults';
-import './QueryEditor.css';
 import {getAdhocFilters} from './helpers/getAdHocFilters';
 import {detectVariableMacroIntersections, createVariableMacroConflictWarning} from './helpers/detectVariableMacroIntersections';
 

src/views/QueryEditor/QueryEditor.tsx

@@ -1,7 +1,15 @@
 import React from 'react';
+import { css } from '@emotion/css';
 import { TagsInput } from '@grafana/ui';
 import { AdhocFilterTagsProps, AdhocFilter } from '../../types';
 
+const tagsInputClassName = css({
+  margin: '5px 0',
+  '> div': {
+    display: 'none',
+  },
+});
+
 export const AdhocFilterTags: React.FC<AdhocFilterTagsProps> = ({ 
   adhocFilters, 
   areAdHocFiltersAvailable, 
@@ -13,7 +21,7 @@ export const AdhocFilterTags: React.FC<AdhocFilterTagsProps> = ({
 
   return (
     <TagsInput
-      className="adhoc-filters-tags"
+      className={tagsInputClassName}
       tags={adhocFilters.map((filter: AdhocFilter) => 
         `${filter.key} ${filter.operator} ${filter.value}`
       )}

src/views/QueryEditor/components/QueryTextEditor/components/AdhocFilterTags/AdhocFilterTags.tsx

@@ -259,12 +259,15 @@ def save_coverage(self):
     with By("executing 'return JSON.stringify(window.__coverage__);' in chrome console"):
         coverage_info = driver.execute_script('return JSON.stringify(window.__coverage__);')
 
-    if not(coverage_info is None):
+    # Skip empty payloads and always write into tests/testflows/coverage/raw
+    if coverage_info not in (None, "null"):
         with By("saving coverage into the file"):
-            timestamp = datetime.datetime.timestamp(datetime.datetime.now())
-            file = open(f"coverage/raw/coverage{timestamp}.json", 'w')
-            file.write(coverage_info)
-            file.close()
+            coverage_dir = os.path.join(current_dir(), "..", "coverage", "raw")
+            os.makedirs(coverage_dir, exist_ok=True)
+            timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S%f")
+            file_path = os.path.join(coverage_dir, f"coverage{timestamp}.json")
+            with open(file_path, "w", encoding="utf-8") as file:
+                file.write(coverage_info)
 
 @TestStep(When)
 def dismiss_alert_if_present(self):