From 7c3f26a7f46a48ce02f760a142afa8e89d188418 Mon Sep 17 00:00:00 2001 From: Alec Sears Date: Tue, 15 Oct 2019 17:18:42 -0500 Subject: [PATCH] Initial Commit --- go.mod | 6 +++- go.sum | 15 ++++++++ pkg/cache.go | 15 ++++++-- pkg/cache_test.go | 68 +++++++++++++++++++++++++++++++++++ pkg/datasource.go | 47 ++++++++++++++++++------ pkg/datasource_test.go | 81 ++++++++++++++++++++++++++++++++++++++++++ pkg/plugin.go | 7 ++-- pkg/zabbix_api.go | 72 ++++++++++++++++++++++--------------- 8 files changed, 266 insertions(+), 45 deletions(-) create mode 100644 pkg/cache_test.go create mode 100644 pkg/datasource_test.go diff --git a/go.mod b/go.mod index 33b0c02..5a74e23 100644 --- a/go.mod +++ b/go.mod @@ -5,10 +5,14 @@ go 1.12 require ( github.com/bitly/go-simplejson v0.5.0 github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 // indirect + github.com/google/go-cmp v0.3.1 // indirect github.com/grafana/grafana_plugin_model v0.0.0-20180518082423-84176c64269d github.com/hashicorp/go-hclog v0.9.2 github.com/hashicorp/go-plugin v1.0.1 github.com/kr/pretty v0.1.0 // indirect github.com/patrickmn/go-cache v2.1.0+incompatible - golang.org/x/net v0.0.0-20180826012351-8a410e7b638d + github.com/pkg/errors v0.8.1 // indirect + golang.org/x/net v0.0.0-20190620200207-3b0461eec859 + golang.org/x/sync v0.0.0-20190423024810-112230192c58 // indirect + gotest.tools v2.2.0+incompatible ) diff --git a/go.sum b/go.sum index b206609..0ae7746 100644 --- a/go.sum +++ b/go.sum @@ -5,9 +5,12 @@ github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dR github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/google/go-cmp v0.3.1 h1:Xye71clBPdm5HgqGwUkwhbynsUJZhDbS20FvLhQ2izg= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/grafana/grafana_plugin_model v0.0.0-20180518082423-84176c64269d h1:Ep6bjWDwurT9NpUATiqa8NYIllmZbLDXLn6Ib4lCtAA= github.com/grafana/grafana_plugin_model v0.0.0-20180518082423-84176c64269d/go.mod h1:70BFhO60E3e7kq+ssiouwX/HX5DvQ3L6XffdH0S2YfU= github.com/hashicorp/go-hclog v0.0.0-20180709165350-ff2cf002a8dd/go.mod h1:9bjs9uLqI8l75knNv3lV1kA55veR+WUPSiKIWcQHudI= @@ -28,20 +31,32 @@ github.com/oklog/run v1.0.0 h1:Ru7dDtJNOyC66gQ5dQmaCa0qIsAUFY3sFpK1Xk8igrw= github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA= github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc= github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ= +github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d h1:g9qWBGx4puODJTMVyoPrpoxPFgVGd+z1DZwjfRu4d0I= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859 h1:R/3boaszxrf1GEUWTVDzSKVwLmSJpwZ1yqXm8j0v2QI= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4 h1:YUO/7uOKsKeq9UokNS62b8FYywz3ker1l1vDZRCRefw= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20190129075346-302c3dd5f1cc h1:WiYx1rIFmx8c0mXAFtv5D/mHyKe1+jmuP7PViuwqwuQ= golang.org/x/sys v0.0.0-20190129075346-302c3dd5f1cc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a h1:1BGLXjeY4akVXGgbC9HugT3Jv3hCI0z56oJR5vAMgBU= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8 h1:Nw54tB0rB7hY/N0NQvRW8DG4Yk3Q6T9cu9RcFQDu1tc= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/grpc v1.14.0 h1:ArxJuB1NWfPY6r9Gp9gqwplT0Ge7nqv9msgu03lHLmo= google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= +gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo= +gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= diff --git a/pkg/cache.go b/pkg/cache.go index 3fc136c..22f52fc 100644 --- a/pkg/cache.go +++ b/pkg/cache.go @@ -3,8 +3,10 @@ package main import ( "crypto/sha1" "encoding/hex" + "encoding/json" "time" + "github.com/grafana/grafana_plugin_model/go/datasource" cache "github.com/patrickmn/go-cache" ) @@ -30,9 +32,18 @@ func (c *Cache) Get(request string) (interface{}, bool) { return c.cache.Get(request) } -// Hash converts the given text string to hash string -func Hash(text string) string { +// HashString converts the given text string to hash string +func HashString(text string) string { hash := sha1.New() hash.Write([]byte(text)) return hex.EncodeToString(hash.Sum(nil)) } + +// HashDatasourceInfo converts the given datasource info to hash string +func HashDatasourceInfo(dsInfo *datasource.DatasourceInfo) string { + digester := sha1.New() + if err := json.NewEncoder(digester).Encode(dsInfo); err != nil { + panic(err) // This shouldn't be possible but just in case DatasourceInfo changes + } + return hex.EncodeToString(digester.Sum(nil)) +} diff --git a/pkg/cache_test.go b/pkg/cache_test.go new file mode 100644 index 0000000..42b5bda --- /dev/null +++ b/pkg/cache_test.go @@ -0,0 +1,68 @@ +package main + +import ( + "testing" + + "github.com/grafana/grafana_plugin_model/go/datasource" + "gotest.tools/assert" +) + +func TestHashDatasourceInfo(t *testing.T) { + tests := []struct { + name string + dsInfo *datasource.DatasourceInfo + want string + }{ + { + name: "Normal Datasource Info", + dsInfo: &datasource.DatasourceInfo{ + Id: 1, + OrgId: 1, + Name: "Zabbix", + Type: "alexanderzobnin-zabbix-datasource", + Url: "https://localhost:3306/zabbix/api_jsonrpc.php", + JsonData: "{}", + DecryptedSecureJsonData: map[string]string{ + "username": "grafanaZabbixUser", + "password": "$uper$ecr3t!!!", + }, + }, + want: "ed161f89179c46d9a578e4d7e92ff95444222e0a", + }, + // Can't find a case where the input causes the encoder to fail + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := HashDatasourceInfo(tt.dsInfo) + assert.Equal(t, tt.want, got) + }) + } +} + +func BenchmarkHashDatasourceInfo(b *testing.B) { + benches := []struct { + name string + dsInfo *datasource.DatasourceInfo + }{ + { + "Normal Datasource Info", + &datasource.DatasourceInfo{ + Id: 4, + OrgId: 6, + Name: "MyZabbixDatasource", + Type: "alexanderzobnin-zabbix-datasource", + Url: "https://localhost:3306/zabbix/api_jsonrpc.php", + JsonData: `{ "addThresholds": true, "disableReadOnlyUsersAck": true }`, + DecryptedSecureJsonData: map[string]string{ + "username": "grafanaZabbixUser", + "password": "$uper$ecr3t!!!", + }, + }, + }, + } + for _, bt := range benches { + b.Run(bt.name, func(b *testing.B) { + HashDatasourceInfo(bt.dsInfo) + }) + } +} diff --git a/pkg/datasource.go b/pkg/datasource.go index 857651a..794735d 100644 --- a/pkg/datasource.go +++ b/pkg/datasource.go @@ -2,6 +2,7 @@ package main import ( "errors" + "fmt" simplejson "github.com/bitly/go-simplejson" "github.com/grafana/grafana_plugin_model/go/datasource" @@ -10,39 +11,63 @@ import ( "golang.org/x/net/context" ) -type ZabbixDatasource struct { +// ZabbixBackend implements the Grafana backend interface and forwards queries to the ZabbixDatasource +type ZabbixBackend struct { plugin.NetRPCUnsupportedPlugin - logger hclog.Logger + logger hclog.Logger + datasourceCache *Cache } -func (ds *ZabbixDatasource) Query(ctx context.Context, tsdbReq *datasource.DatasourceRequest) (*datasource.DatasourceResponse, error) { +func (b *ZabbixBackend) newZabbixDatasource() *ZabbixDatasource { + ds := NewZabbixDatasource() + ds.logger = b.logger + return ds +} + +// Query receives requests from the Grafana backend. Requests are filtered by query type and sent to the +// applicable ZabbixDatasource. +func (b *ZabbixBackend) Query(ctx context.Context, tsdbReq *datasource.DatasourceRequest) (*datasource.DatasourceResponse, error) { + zabbixDs := b.getCachedDatasource(tsdbReq) + queryType, err := GetQueryType(tsdbReq) if err != nil { return nil, err } - dsInfo := tsdbReq.GetDatasource() - ds.logger.Debug("createRequest", "dsInfo", dsInfo) - - ds.logger.Debug("createRequest", "queryType", queryType) - switch queryType { case "zabbixAPI": - return ds.ZabbixAPIQuery(ctx, tsdbReq) + return zabbixDs.ZabbixAPIQuery(ctx, tsdbReq) default: return nil, errors.New("Query is not implemented yet") } } +func (b *ZabbixBackend) getCachedDatasource(tsdbReq *datasource.DatasourceRequest) *ZabbixDatasource { + dsInfoHash := HashDatasourceInfo(tsdbReq.GetDatasource()) + + if cachedData, ok := b.datasourceCache.Get(dsInfoHash); ok { + if cachedDS, ok := cachedData.(*ZabbixDatasource); ok { + return cachedDS + } + } + + if b.logger.IsDebug() { + dsInfo := tsdbReq.GetDatasource() + b.logger.Debug(fmt.Sprintf("Datasource cache miss (Org %d Id %d '%s' %s)", dsInfo.GetOrgId(), dsInfo.GetId(), dsInfo.GetName(), dsInfoHash)) + } + return b.newZabbixDatasource() +} + +// GetQueryType determines the query type from a query or list of queries func GetQueryType(tsdbReq *datasource.DatasourceRequest) (string, error) { queryType := "query" if len(tsdbReq.Queries) > 0 { firstQuery := tsdbReq.Queries[0] - queryJson, err := simplejson.NewJson([]byte(firstQuery.ModelJson)) + queryJSON, err := simplejson.NewJson([]byte(firstQuery.ModelJson)) if err != nil { return "", err } - queryType = queryJson.Get("queryType").MustString("query") + queryType = queryJSON.Get("queryType").MustString("query") } return queryType, nil } diff --git a/pkg/datasource_test.go b/pkg/datasource_test.go new file mode 100644 index 0000000..b713569 --- /dev/null +++ b/pkg/datasource_test.go @@ -0,0 +1,81 @@ +package main + +import ( + "testing" + + "github.com/grafana/grafana_plugin_model/go/datasource" + hclog "github.com/hashicorp/go-hclog" + cache "github.com/patrickmn/go-cache" + "gotest.tools/assert" +) + +func TestZabbixBackend_getCachedDatasource(t *testing.T) { + basicDatasourceInfo := &datasource.DatasourceInfo{ + Id: 1, + Name: "TestDatasource", + } + basicDatasourceInfoHash := HashDatasourceInfo(basicDatasourceInfo) + + modifiedDatasource := NewZabbixDatasource() + modifiedDatasource.authToken = "AB404F1234" + + altDatasourceInfo := &datasource.DatasourceInfo{ + Id: 2, + Name: "AnotherDatasource", + } + altDatasourceInfoHash := HashDatasourceInfo(altDatasourceInfo) + + tests := []struct { + name string + cache *cache.Cache + request *datasource.DatasourceRequest + want *ZabbixDatasource + }{ + { + name: "Uncached Datasource (nothing in cache)", + request: &datasource.DatasourceRequest{ + Datasource: basicDatasourceInfo, + }, + want: NewZabbixDatasource(), + }, + { + name: "Uncached Datasource (cache miss)", + cache: cache.NewFrom(cache.NoExpiration, cache.NoExpiration, map[string]cache.Item{ + basicDatasourceInfoHash: cache.Item{Object: modifiedDatasource}, + }), + request: &datasource.DatasourceRequest{ + Datasource: altDatasourceInfo, + }, + want: NewZabbixDatasource(), + }, + { + name: "Cached Datasource", + cache: cache.NewFrom(cache.NoExpiration, cache.NoExpiration, map[string]cache.Item{ + altDatasourceInfoHash: cache.Item{Object: NewZabbixDatasource()}, + basicDatasourceInfoHash: cache.Item{Object: modifiedDatasource}, + }), + request: &datasource.DatasourceRequest{ + Datasource: basicDatasourceInfo, + }, + want: modifiedDatasource, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if tt.cache == nil { + tt.cache = cache.New(cache.NoExpiration, cache.NoExpiration) + } + b := &ZabbixBackend{ + logger: hclog.New(&hclog.LoggerOptions{ + Name: "TestZabbixBackend_getCachedDatasource", + Level: hclog.LevelFromString("DEBUG"), + }), + datasourceCache: &Cache{cache: tt.cache}, + } + got := b.getCachedDatasource(tt.request) + + // Only checking the authToken, being the easiest value to, and guarantee equality for + assert.Equal(t, tt.want.authToken, got.authToken) + }) + } +} diff --git a/pkg/plugin.go b/pkg/plugin.go index 151887c..33b5442 100644 --- a/pkg/plugin.go +++ b/pkg/plugin.go @@ -1,6 +1,8 @@ package main import ( + "time" + "github.com/grafana/grafana_plugin_model/go/datasource" hclog "github.com/hashicorp/go-hclog" plugin "github.com/hashicorp/go-plugin" @@ -22,8 +24,9 @@ func main() { MagicCookieValue: "datasource", }, Plugins: map[string]plugin.Plugin{ - "zabbix-backend-datasource": &datasource.DatasourcePluginImpl{Plugin: &ZabbixDatasource{ - logger: pluginLogger, + "zabbix-backend-datasource": &datasource.DatasourcePluginImpl{Plugin: &ZabbixBackend{ + datasourceCache: NewCache(10*time.Minute, 10*time.Minute), + logger: pluginLogger, }}, }, diff --git a/pkg/zabbix_api.go b/pkg/zabbix_api.go index 0f3da0d..bf68370 100644 --- a/pkg/zabbix_api.go +++ b/pkg/zabbix_api.go @@ -15,35 +15,47 @@ import ( simplejson "github.com/bitly/go-simplejson" "github.com/grafana/grafana_plugin_model/go/datasource" + hclog "github.com/hashicorp/go-hclog" "golang.org/x/net/context" "golang.org/x/net/context/ctxhttp" ) -var httpClient = &http.Client{ - Transport: &http.Transport{ - TLSClientConfig: &tls.Config{ - Renegotiation: tls.RenegotiateFreelyAsClient, - }, - Proxy: http.ProxyFromEnvironment, - Dial: (&net.Dialer{ - Timeout: 30 * time.Second, - KeepAlive: 30 * time.Second, - DualStack: true, - }).Dial, - TLSHandshakeTimeout: 10 * time.Second, - ExpectContinueTimeout: 1 * time.Second, - MaxIdleConns: 100, - IdleConnTimeout: 90 * time.Second, - }, - Timeout: time.Duration(time.Second * 30), +// ZabbixDatasource stores state about a specific datasource and provides methods to make +// requests to the Zabbix API +type ZabbixDatasource struct { + queryCache *Cache + logger hclog.Logger + httpClient *http.Client + authToken string } -var queryCache = NewCache(10*time.Minute, 10*time.Minute) - -var zabbixAuth string = "" +// NewZabbixDatasource returns an initialized ZabbixDatasource +func NewZabbixDatasource() *ZabbixDatasource { + return &ZabbixDatasource{ + queryCache: NewCache(10*time.Minute, 10*time.Minute), + httpClient: &http.Client{ + Transport: &http.Transport{ + TLSClientConfig: &tls.Config{ + Renegotiation: tls.RenegotiateFreelyAsClient, + }, + Proxy: http.ProxyFromEnvironment, + Dial: (&net.Dialer{ + Timeout: 30 * time.Second, + KeepAlive: 30 * time.Second, + }).Dial, + TLSHandshakeTimeout: 10 * time.Second, + ExpectContinueTimeout: 1 * time.Second, + MaxIdleConns: 100, + IdleConnTimeout: 90 * time.Second, + }, + Timeout: time.Duration(time.Second * 30), + }, + } +} +// ZabbixAPIQuery handles query requests to Zabbix func (ds *ZabbixDatasource) ZabbixAPIQuery(ctx context.Context, tsdbReq *datasource.DatasourceRequest) (*datasource.DatasourceResponse, error) { - result, queryExistInCache := queryCache.Get(Hash(tsdbReq.String())) + result, queryExistInCache := ds.queryCache.Get(HashString(tsdbReq.String())) if !queryExistInCache { dsInfo := tsdbReq.GetDatasource() @@ -86,8 +98,8 @@ func (ds *ZabbixDatasource) ZabbixAPIQuery(ctx context.Context, tsdbReq *datasou apiMethod := jsonQuery.Get("method").MustString() apiParams := jsonQuery.Get("params") - result, err = ds.ZabbixRequest(ctx, dsInfo, apiMethod, apiParams) - queryCache.Set(Hash(tsdbReq.String()), result) + result, err := ds.ZabbixRequest(ctx, dsInfo, apiMethod, apiParams) + ds.queryCache.Set(HashString(tsdbReq.String()), result) if err != nil { ds.logger.Debug("ZabbixAPIQuery", "error", err) return nil, errors.New("ZabbixAPIQuery is not implemented yet") @@ -100,6 +112,7 @@ func (ds *ZabbixDatasource) ZabbixAPIQuery(ctx context.Context, tsdbReq *datasou return ds.BuildResponse(result.(*simplejson.Json)) } +// BuildResponse transforms a Zabbix API response to a DatasourceResponse func (ds *ZabbixDatasource) BuildResponse(result *simplejson.Json) (*datasource.DatasourceResponse, error) { resultByte, err := result.MarshalJSON() if err != nil { @@ -116,19 +129,20 @@ func (ds *ZabbixDatasource) BuildResponse(result *simplejson.Json) (*datasource. }, nil } +// ZabbixRequest checks authentication and makes a request to the Zabbix API func (ds *ZabbixDatasource) ZabbixRequest(ctx context.Context, dsInfo *datasource.DatasourceInfo, method string, params *simplejson.Json) (*simplejson.Json, error) { - zabbixUrl := dsInfo.GetUrl() + zabbixURL := dsInfo.GetUrl() // Authenticate first - if zabbixAuth == "" { + if ds.authToken == "" { auth, err := ds.loginWithDs(ctx, dsInfo) if err != nil { return nil, err } - zabbixAuth = auth + ds.authToken = auth } - return ds.zabbixAPIRequest(ctx, zabbixUrl, method, params, zabbixAuth) + return ds.zabbixAPIRequest(ctx, zabbixURL, method, params, ds.authToken) } func (ds *ZabbixDatasource) loginWithDs(ctx context.Context, dsInfo *datasource.DatasourceInfo) (string, error) { @@ -210,7 +224,7 @@ func (ds *ZabbixDatasource) zabbixAPIRequest(ctx context.Context, apiUrl string, Body: rc, } - response, err := makeHttpRequest(ctx, req) + response, err := makeHTTPRequest(ctx, ds.httpClient, req) if err != nil { return nil, err } @@ -233,7 +247,7 @@ func handleApiResult(response []byte) (*simplejson.Json, error) { return jsonResult, nil } -func makeHttpRequest(ctx context.Context, req *http.Request) ([]byte, error) { +func makeHTTPRequest(ctx context.Context, httpClient *http.Client, req *http.Request) ([]byte, error) { res, err := ctxhttp.Do(ctx, httpClient, req) if err != nil { return nil, err