From 895c1768a5c77009c799f0d8341c91707ce900f2 Mon Sep 17 00:00:00 2001 From: Matthieu MOREL Date: Thu, 25 Sep 2025 17:56:11 +0200 Subject: [PATCH] [chore]: enable noctx linter Signed-off-by: Matthieu MOREL --- .github/workflows/build-and-test.yml | 2 +- .golangci.yml | 2 + cmd/opampsupervisor/e2e_test.go | 50 ++++++++++++++++--- .../supervisor/supervisor_test.go | 22 ++++---- exporter/mezmoexporter/exporter.go | 14 +++--- .../prometheusexporter/end_to_end_test.go | 4 +- .../prometheusexporter/prometheus_test.go | 40 ++++++++++----- .../exporter_concurrency_test.go | 4 +- .../internal/apm/correlations/client.go | 6 +-- .../internal/integrationtestutils/splunk.go | 11 ++-- exporter/zipkinexporter/zipkin_test.go | 11 ++-- extension/awsproxy/factory_test.go | 10 ++-- .../datadogextension/integration_test.go | 2 +- .../internal/httpserver/httpserver_test.go | 7 ++- .../healthcheckextension_test.go | 4 +- .../healthcheckextension/integration_test.go | 8 ++- .../httpforwarderextension/extension_test.go | 2 +- .../jaegerremotesampling/extension_test.go | 4 +- .../internal/server/http/http_test.go | 4 +- .../extension_test.go | 2 +- extension/opampextension/auth.go | 3 +- .../pprofextension/pprofextension_test.go | 4 +- .../sigv4authextension/extension_test.go | 4 +- .../signingroundtripper_test.go | 22 ++++---- .../extension.go | 2 +- .../extension_test.go | 2 +- internal/aws/ecsutil/client.go | 2 +- .../aws/xray/testdata/sampleserver/sample.go | 7 ++- internal/datadog/hostmetadata/metadata.go | 2 +- internal/healthcheck/extension_test.go | 8 ++- .../healthcheck/internal/http/server_test.go | 13 +++-- internal/kubelet/client.go | 3 +- receiver/apachereceiver/integration_test.go | 6 ++- receiver/apachereceiver/scraper.go | 6 ++- receiver/apachesparkreceiver/client.go | 2 +- receiver/cloudflarereceiver/fuzz_test.go | 2 +- .../logs_integration_test.go | 2 +- receiver/collectdreceiver/receiver_test.go | 3 +- receiver/couchdbreceiver/client.go | 2 +- .../internal/translator/series_test.go | 2 +- .../internal/translator/sketches_test.go | 2 +- .../translator/traces_translator_test.go | 10 ++-- receiver/datadogreceiver/receiver_test.go | 24 ++++++--- receiver/faroreceiver/receiver_test.go | 2 +- receiver/haproxyreceiver/scraper.go | 6 ++- .../jaegerreceiver/trace_receiver_test.go | 2 +- receiver/jmxreceiver/integration_test.go | 6 ++- receiver/libhoneyreceiver/receiver.go | 2 +- receiver/lokireceiver/internal/fuzz_test.go | 2 +- receiver/lokireceiver/internal/push_test.go | 3 +- receiver/lokireceiver/loki_test.go | 10 ++-- .../alerts_integration_test.go | 4 +- receiver/mongodbatlasreceiver/fuzz_test.go | 2 +- .../metricsreceiver_api_server_test.go | 29 +++++++---- .../targetallocator/manager.go | 6 ++- .../receiver_test.go | 18 +++---- receiver/signalfxreceiver/fuzz_test.go | 2 +- receiver/signalfxreceiver/receiver_test.go | 2 +- .../skywalking_receiver_test.go | 2 +- .../splunkenterprisereceiver/client_test.go | 25 +++++----- receiver/splunkhecreceiver/fuzz_test.go | 2 +- receiver/webhookeventreceiver/fuzz_test.go | 2 +- 62 files changed, 303 insertions(+), 166 deletions(-) diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml index 811db0945f6af..27e2f09608c44 100644 --- a/.github/workflows/build-and-test.yml +++ b/.github/workflows/build-and-test.yml @@ -86,7 +86,7 @@ jobs: if: steps.go-setup.outputs.cache-hit != 'true' run: make install-tools - name: Lint - run: GOOS=${{ matrix.goos }} GOARCH=amd64 make -j2 golint GROUP=${{ matrix.group }} + run: GOOS=${{ matrix.goos }} GOARCH=amd64 make -j2 golint -k GROUP=${{ matrix.group }} lint: if: ${{ github.actor != 'dependabot[bot]' && always() }} runs-on: ubuntu-24.04 diff --git a/.golangci.yml b/.golangci.yml index f527884de9961..db2b9d594bf80 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -26,6 +26,7 @@ issues: linters: enable: + - contextcheck - copyloopvar - decorder - depguard @@ -36,6 +37,7 @@ linters: - gosec - govet - misspell + - noctx - nolintlint - predeclared - reassign diff --git a/cmd/opampsupervisor/e2e_test.go b/cmd/opampsupervisor/e2e_test.go index 08e5c035b2dec..b442bf7123107 100644 --- a/cmd/opampsupervisor/e2e_test.go +++ b/cmd/opampsupervisor/e2e_test.go @@ -487,7 +487,12 @@ func TestSupervisorStartsCollectorWithNoOpAMPServerWithNoLastRemoteConfig(t *tes // Verify the collector runs eventually by pinging the healthcheck extension require.Eventually(t, func() bool { - resp, err := http.DefaultClient.Get("http://localhost:13133") + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://localhost:13133", http.NoBody) + if err != nil { + t.Logf("Failed to create request: %s", err) + return false + } + resp, err := http.DefaultClient.Do(req) if err != nil { t.Logf("Failed healthcheck: %s", err) return false @@ -559,7 +564,12 @@ func TestSupervisorStartsCollectorWithNoOpAMPServerUsingLastRemoteConfig(t *test // Verify the collector runs eventually by pinging the healthcheck extension require.Eventually(t, func() bool { - resp, err := http.DefaultClient.Get(fmt.Sprintf("http://localhost:%d", healthcheckPort)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, fmt.Sprintf("http://localhost:%d", healthcheckPort), http.NoBody) + if err != nil { + t.Logf("Failed to create request: %s", err) + return false + } + resp, err := http.DefaultClient.Do(req) if err != nil { t.Logf("Failed healthcheck: %s", err) return false @@ -647,7 +657,12 @@ func TestSupervisorStartsCollectorWithRemoteConfigAndExecParams(t *testing.T) { for _, port := range []int{healthcheckPort, secondHealthcheckPort} { require.Eventually(t, func() bool { - resp, err := http.DefaultClient.Get(fmt.Sprintf("http://localhost:%d", port)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, fmt.Sprintf("http://localhost:%d", port), http.NoBody) + if err != nil { + t.Logf("Failed to create request: %s", err) + return false + } + resp, err := http.DefaultClient.Do(req) if err != nil { t.Logf("Failed healthcheck: %s", err) return false @@ -707,7 +722,9 @@ func TestSupervisorStartsWithNoOpAMPServer(t *testing.T) { // Verify the collector is not running after 250 ms by checking the healthcheck endpoint time.Sleep(250 * time.Millisecond) - _, err := http.DefaultClient.Get("http://localhost:12345") + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://localhost:12345", http.NoBody) + require.NoError(t, err) + _, err = http.DefaultClient.Do(req) if runtime.GOOS != "windows" { require.ErrorContains(t, err, "connection refused") @@ -1911,7 +1928,12 @@ func TestSupervisorStopsAgentProcessWithEmptyConfigMap(t *testing.T) { // Use health check endpoint to determine if the collector is actually running require.Eventually(t, func() bool { - resp, err := http.DefaultClient.Get("http://localhost:13133") + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://localhost:13133", http.NoBody) + if err != nil { + t.Logf("Failed to create request: %s", err) + return false + } + resp, err := http.DefaultClient.Do(req) if err != nil { t.Logf("Failed agent healthcheck request: %s", err) return false @@ -1943,7 +1965,9 @@ func TestSupervisorStopsAgentProcessWithEmptyConfigMap(t *testing.T) { // Verify the collector is not running after 250 ms by checking the healthcheck endpoint require.EventuallyWithT(t, func(tt *assert.CollectT) { - _, err := http.DefaultClient.Get("http://localhost:12345") + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://localhost:12345", http.NoBody) + assert.NoError(tt, err) + _, err = http.DefaultClient.Do(req) if runtime.GOOS != "windows" { assert.ErrorContains(tt, err, "connection refused") } else { @@ -2319,7 +2343,12 @@ func TestSupervisorHealthCheckServer(t *testing.T) { // Wait for the health check server to start require.Eventually(t, func() bool { - resp, err := http.Get(fmt.Sprintf("http://localhost:%d/health", randomPort)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, fmt.Sprintf("http://localhost:%d/health", randomPort), http.NoBody) + if err != nil { + t.Logf("Failed to create request: %s", err) + return false + } + resp, err := http.DefaultClient.Do(req) if err != nil { t.Logf("Failed health check request: %s", err) return false @@ -2358,7 +2387,12 @@ func TestSupervisorHealthCheckServerBackendConnError(t *testing.T) { // Wait for the health check server to start require.Eventually(t, func() bool { - resp, err := http.Get(fmt.Sprintf("http://localhost:%d/health", healthcheckPort)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, fmt.Sprintf("http://localhost:%d/health", healthcheckPort), http.NoBody) + if err != nil { + t.Logf("Failed to create request: %s", err) + return false + } + resp, err := http.DefaultClient.Do(req) if err != nil { t.Logf("Failed health check request: %s", err) return false diff --git a/cmd/opampsupervisor/supervisor/supervisor_test.go b/cmd/opampsupervisor/supervisor/supervisor_test.go index 0f91a08d21203..d28a2400ac21a 100644 --- a/cmd/opampsupervisor/supervisor/supervisor_test.go +++ b/cmd/opampsupervisor/supervisor/supervisor_test.go @@ -2125,12 +2125,16 @@ func TestSupervisor_HealthCheckServer(t *testing.T) { addr := fmt.Sprintf("localhost:%d", s.config.HealthCheck.Port()) require.NotEmpty(t, addr) - sendHealthCheckRequest := func() (*http.Response, error) { - return http.Get(fmt.Sprintf("http://%s/health", addr)) + sendHealthCheckRequest := func(t *testing.T) (*http.Response, error) { + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, fmt.Sprintf("http://%s/health", addr), http.NoBody) + if err != nil { + return nil, err + } + return http.DefaultClient.Do(req) } t.Run("Health check server startup", func(t *testing.T) { - resp, respErr := sendHealthCheckRequest() + resp, respErr := sendHealthCheckRequest(t) require.NoError(t, respErr) defer resp.Body.Close() body, bodyErr := io.ReadAll(resp.Body) @@ -2142,7 +2146,7 @@ func TestSupervisor_HealthCheckServer(t *testing.T) { s.cfgState.Store(healthyConfig) s.persistentState = &persistentState{InstanceID: testUUID} - resp, respErr := sendHealthCheckRequest() + resp, respErr := sendHealthCheckRequest(t) require.NoError(t, respErr) defer resp.Body.Close() assert.Equal(t, http.StatusOK, resp.StatusCode) @@ -2155,7 +2159,7 @@ func TestSupervisor_HealthCheckServer(t *testing.T) { }) s.persistentState = nil - resp, respErr := sendHealthCheckRequest() + resp, respErr := sendHealthCheckRequest(t) require.NoError(t, respErr) defer resp.Body.Close() assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode) @@ -2168,7 +2172,7 @@ func TestSupervisor_HealthCheckServer(t *testing.T) { }) s.cfgState = &atomic.Value{} - resp, respErr := sendHealthCheckRequest() + resp, respErr := sendHealthCheckRequest(t) require.NoError(t, respErr) defer resp.Body.Close() assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode) @@ -2181,7 +2185,7 @@ func TestSupervisor_HealthCheckServer(t *testing.T) { }) s.cfgState = &atomic.Value{} - resp, respErr := sendHealthCheckRequest() + resp, respErr := sendHealthCheckRequest(t) require.NoError(t, respErr) defer resp.Body.Close() assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode) @@ -2207,14 +2211,14 @@ func TestSupervisor_HealthCheckServer(t *testing.T) { }) t.Run("Health check server shutdown is handled gracefully in Supervisor.Shutdown", func(t *testing.T) { - resp, err := sendHealthCheckRequest() + resp, err := sendHealthCheckRequest(t) require.NoError(t, err) resp.Body.Close() assert.Equal(t, http.StatusOK, resp.StatusCode) s.Shutdown() - _, err = sendHealthCheckRequest() + _, err = sendHealthCheckRequest(t) assert.Error(t, err) }) } diff --git a/exporter/mezmoexporter/exporter.go b/exporter/mezmoexporter/exporter.go index e077c22bdca2b..11713371e3a40 100644 --- a/exporter/mezmoexporter/exporter.go +++ b/exporter/mezmoexporter/exporter.go @@ -50,11 +50,11 @@ func newLogsExporter(config *Config, settings component.TelemetrySettings, build return e } -func (m *mezmoExporter) pushLogData(_ context.Context, ld plog.Logs) error { +func (m *mezmoExporter) pushLogData(ctx context.Context, ld plog.Logs) error { m.wg.Add(1) defer m.wg.Done() - return m.logDataToMezmo(ld) + return m.logDataToMezmo(ctx, ld) } func (m *mezmoExporter) start(ctx context.Context, host component.Host) (err error) { @@ -72,7 +72,7 @@ func (m *mezmoExporter) stop(context.Context) (err error) { return nil } -func (m *mezmoExporter) logDataToMezmo(ld plog.Logs) error { +func (m *mezmoExporter) logDataToMezmo(ctx context.Context, ld plog.Logs) error { var errs error var lines []mezmoLogLine @@ -147,7 +147,7 @@ func (m *mezmoExporter) logDataToMezmo(ld plog.Logs) error { if newBufSize >= maxBodySize-2 { str := b.String() str = str[:len(str)-1] + "]}" - if errs := m.sendLinesToMezmo(str); errs != nil { + if errs := m.sendLinesToMezmo(ctx, str); errs != nil { return errs } b.Reset() @@ -161,11 +161,11 @@ func (m *mezmoExporter) logDataToMezmo(ld plog.Logs) error { } } - return m.sendLinesToMezmo(b.String() + "]}") + return m.sendLinesToMezmo(ctx, b.String()+"]}") } -func (m *mezmoExporter) sendLinesToMezmo(post string) (errs error) { - req, _ := http.NewRequest(http.MethodPost, m.config.IngestURL, strings.NewReader(post)) +func (m *mezmoExporter) sendLinesToMezmo(ctx context.Context, post string) (errs error) { + req, _ := http.NewRequestWithContext(ctx, http.MethodPost, m.config.IngestURL, strings.NewReader(post)) req.Header.Add("Accept", "application/json") req.Header.Add("Content-Type", "application/json") req.Header.Add("User-Agent", m.userAgentString) diff --git a/exporter/prometheusexporter/end_to_end_test.go b/exporter/prometheusexporter/end_to_end_test.go index cf904357f9d11..53687cf35f4da 100644 --- a/exporter/prometheusexporter/end_to_end_test.go +++ b/exporter/prometheusexporter/end_to_end_test.go @@ -100,7 +100,9 @@ func TestEndToEndSummarySupport(t *testing.T) { // 4. Scrape from the Prometheus receiver to ensure that we export summary metrics wg.Wait() - res, err := http.Get("http://" + exporterCfg.Endpoint + "/metrics") + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://"+exporterCfg.Endpoint+"/metrics", http.NoBody) + require.NoError(t, err) + res, err := http.DefaultClient.Do(req) require.NoError(t, err, "Failed to scrape from the exporter") prometheusExporterScrape, err := io.ReadAll(res.Body) res.Body.Close() diff --git a/exporter/prometheusexporter/prometheus_test.go b/exporter/prometheusexporter/prometheus_test.go index 8aaa01d5ba0d9..f39139f89ecaa 100644 --- a/exporter/prometheusexporter/prometheus_test.go +++ b/exporter/prometheusexporter/prometheus_test.go @@ -153,7 +153,9 @@ func TestPrometheusExporter_WithTLS(t *testing.T) { assert.NoError(t, exp.ConsumeMetrics(t.Context(), md)) - rsp, err := httpClient.Get("https://" + addr + "/metrics") + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://"+addr+"/metrics", http.NoBody) + require.NoError(t, err) + rsp, err := httpClient.Do(req) require.NoError(t, err, "Failed to perform a scrape") assert.Equal(t, http.StatusOK, rsp.StatusCode, "Mismatched HTTP response status code") @@ -209,8 +211,10 @@ func TestPrometheusExporter_endToEndMultipleTargets(t *testing.T) { assert.NoError(t, exp.ConsumeMetrics(t.Context(), metricBuilder(int64(delta), "metric_2_", "cpu-exporter", "localhost:8080"))) assert.NoError(t, exp.ConsumeMetrics(t.Context(), metricBuilder(int64(delta), "metric_2_", "cpu-exporter", "localhost:8081"))) - res, err1 := http.Get("http://" + addr + "/metrics") - require.NoError(t, err1, "Failed to perform a scrape") + req, err1 := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://"+addr+"/metrics", http.NoBody) + require.NoError(t, err1) + res, err2 := http.DefaultClient.Do(req) + require.NoError(t, err2, "Failed to perform a scrape") assert.Equal(t, http.StatusOK, res.StatusCode, "Mismatched HTTP response status code") blob, _ := io.ReadAll(res.Body) @@ -239,7 +243,9 @@ func TestPrometheusExporter_endToEndMultipleTargets(t *testing.T) { exp.(*wrapMetricsExporter).exporter.collector.accumulator.(*lastValueAccumulator).metricExpiration = 1 * time.Millisecond time.Sleep(10 * time.Millisecond) - res, err := http.Get("http://" + addr + "/metrics") + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://"+addr+"/metrics", http.NoBody) + require.NoError(t, err) + res, err := http.DefaultClient.Do(req) require.NoError(t, err, "Failed to perform a scrape") assert.Equal(t, http.StatusOK, res.StatusCode, "Mismatched HTTP response status code") @@ -281,8 +287,10 @@ func TestPrometheusExporter_endToEnd(t *testing.T) { for delta := 0; delta <= 20; delta += 10 { assert.NoError(t, exp.ConsumeMetrics(t.Context(), metricBuilder(int64(delta), "metric_2_", "cpu-exporter", "localhost:8080"))) - res, err1 := http.Get("http://" + addr + "/metrics") - require.NoError(t, err1, "Failed to perform a scrape") + req, err1 := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://"+addr+"/metrics", http.NoBody) + require.NoError(t, err1) + res, err2 := http.DefaultClient.Do(req) + require.NoError(t, err2, "Failed to perform a scrape") assert.Equal(t, http.StatusOK, res.StatusCode, "Mismatched HTTP response status code") blob, _ := io.ReadAll(res.Body) @@ -307,7 +315,9 @@ func TestPrometheusExporter_endToEnd(t *testing.T) { exp.(*wrapMetricsExporter).exporter.collector.accumulator.(*lastValueAccumulator).metricExpiration = 1 * time.Millisecond time.Sleep(10 * time.Millisecond) - res, err := http.Get("http://" + addr + "/metrics") + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://"+addr+"/metrics", http.NoBody) + require.NoError(t, err) + res, err := http.DefaultClient.Do(req) require.NoError(t, err, "Failed to perform a scrape") assert.Equal(t, http.StatusOK, res.StatusCode, "Mismatched HTTP response status code") @@ -350,8 +360,10 @@ func TestPrometheusExporter_endToEndWithTimestamps(t *testing.T) { for delta := 0; delta <= 20; delta += 10 { assert.NoError(t, exp.ConsumeMetrics(t.Context(), metricBuilder(int64(delta), "metric_2_", "node-exporter", "localhost:8080"))) - res, err1 := http.Get("http://" + addr + "/metrics") - require.NoError(t, err1, "Failed to perform a scrape") + req, err1 := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://"+addr+"/metrics", http.NoBody) + require.NoError(t, err1) + res, err2 := http.DefaultClient.Do(req) + require.NoError(t, err2, "Failed to perform a scrape") assert.Equal(t, http.StatusOK, res.StatusCode, "Mismatched HTTP response status code") blob, _ := io.ReadAll(res.Body) @@ -376,7 +388,9 @@ func TestPrometheusExporter_endToEndWithTimestamps(t *testing.T) { exp.(*wrapMetricsExporter).exporter.collector.accumulator.(*lastValueAccumulator).metricExpiration = 1 * time.Millisecond time.Sleep(10 * time.Millisecond) - res, err := http.Get("http://" + addr + "/metrics") + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://"+addr+"/metrics", http.NoBody) + require.NoError(t, err) + res, err := http.DefaultClient.Do(req) require.NoError(t, err, "Failed to perform a scrape") assert.Equal(t, http.StatusOK, res.StatusCode, "Mismatched HTTP response status code") @@ -420,7 +434,9 @@ func TestPrometheusExporter_endToEndWithResource(t *testing.T) { assert.NoError(t, exp.ConsumeMetrics(t.Context(), md)) - rsp, err := http.Get("http://" + addr + "/metrics") + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://"+addr+"/metrics", http.NoBody) + require.NoError(t, err) + rsp, err := http.DefaultClient.Do(req) require.NoError(t, err, "Failed to perform a scrape") assert.Equal(t, http.StatusOK, rsp.StatusCode, "Mismatched HTTP response status code") @@ -679,7 +695,7 @@ this_one_there_where_{arch="x86",instance="test-instance",job="test-service",os= assert.NoError(t, exp.ConsumeMetrics(t.Context(), md)) // Scrape metrics, with the Accept header set to the value specified in the test case - req, err := http.NewRequest(http.MethodGet, "http://"+addr+"/metrics", http.NoBody) + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://"+addr+"/metrics", http.NoBody) require.NoError(t, err) for k, v := range tt.extraHeaders { req.Header.Set(k, v) diff --git a/exporter/prometheusremotewriteexporter/exporter_concurrency_test.go b/exporter/prometheusremotewriteexporter/exporter_concurrency_test.go index e8219464e4692..6480a00ef7460 100644 --- a/exporter/prometheusremotewriteexporter/exporter_concurrency_test.go +++ b/exporter/prometheusremotewriteexporter/exporter_concurrency_test.go @@ -129,7 +129,9 @@ func Test_PushMetricsConcurrent(t *testing.T) { // Ensure that the test server is up before making the requests assert.EventuallyWithT(t, func(c *assert.CollectT) { - resp, checkRequestErr := http.Get(server.URL) + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, server.URL, http.NoBody) + require.NoError(c, err) + resp, checkRequestErr := http.DefaultClient.Do(req) require.NoError(c, checkRequestErr) assert.NoError(c, resp.Body.Close()) }, 15*time.Second, 100*time.Millisecond) diff --git a/exporter/signalfxexporter/internal/apm/correlations/client.go b/exporter/signalfxexporter/internal/apm/correlations/client.go index edd99670ea510..ead777c7ef89f 100644 --- a/exporter/signalfxexporter/internal/apm/correlations/client.go +++ b/exporter/signalfxexporter/internal/apm/correlations/client.go @@ -279,15 +279,15 @@ func (cc *Client) makeRequest(r *request) { switch r.operation { case http.MethodGet: - req, err = http.NewRequest(r.operation, endpoint, http.NoBody) + req, err = http.NewRequestWithContext(context.Background(), r.operation, endpoint, http.NoBody) case http.MethodPut: // TODO: pool the reader endpoint = fmt.Sprintf("%s/%s", endpoint, r.Type) - req, err = http.NewRequest(r.operation, endpoint, strings.NewReader(r.Value)) + req, err = http.NewRequestWithContext(context.Background(), r.operation, endpoint, strings.NewReader(r.Value)) req.Header.Add("Content-Type", "text/plain") case http.MethodDelete: endpoint = fmt.Sprintf("%s/%s/%s", endpoint, r.Type, url.PathEscape(r.Value)) - req, err = http.NewRequest(r.operation, endpoint, http.NoBody) + req, err = http.NewRequestWithContext(context.Background(), r.operation, endpoint, http.NoBody) default: err = errors.New("unknown operation") } diff --git a/exporter/splunkhecexporter/internal/integrationtestutils/splunk.go b/exporter/splunkhecexporter/internal/integrationtestutils/splunk.go index ba1030bb75c28..a422c8407600a 100644 --- a/exporter/splunkhecexporter/internal/integrationtestutils/splunk.go +++ b/exporter/splunkhecexporter/internal/integrationtestutils/splunk.go @@ -4,6 +4,7 @@ package integrationtestutils // import "github.com/open-telemetry/opentelemetry-collector-contrib/exporter/splunkhecexporter/internal/integrationtestutils" import ( + "context" "crypto/tls" "encoding/json" "fmt" @@ -47,7 +48,7 @@ func getSplunkSearchResults(user, password, baseURL, jobID string) []any { logger := log.New(os.Stdout, "", log.LstdFlags) eventURL := fmt.Sprintf("%s/services/search/jobs/%s/events?output_mode=json", baseURL, jobID) logger.Println("URL: " + eventURL) - reqEvents, err := http.NewRequest(http.MethodGet, eventURL, http.NoBody) + reqEvents, err := http.NewRequestWithContext(context.Background(), http.MethodGet, eventURL, http.NoBody) if err != nil { panic(err) } @@ -89,7 +90,7 @@ func checkSearchJobStatusCode(user, password, baseURL, jobID string) any { TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, } client := &http.Client{Transport: tr} - checkReqEvents, err := http.NewRequest(http.MethodGet, checkEventURL, http.NoBody) + checkReqEvents, err := http.NewRequestWithContext(context.Background(), http.MethodGet, checkEventURL, http.NoBody) if err != nil { panic(err) } @@ -130,7 +131,7 @@ func postSearchRequest(user, password, baseURL, searchQuery, startTime, endTime TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, } client := &http.Client{Transport: tr} - req, err := http.NewRequest(http.MethodPost, searchURL, strings.NewReader(data.Encode())) + req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, searchURL, strings.NewReader(data.Encode())) if err != nil { logger.Printf("Error while preparing POST request") panic(err) @@ -173,7 +174,7 @@ func CheckMetricsFromSplunk(index, metricName string) []any { TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, } client := &http.Client{Transport: tr, Timeout: 10 * time.Second} - req, err := http.NewRequest(http.MethodGet, apiURL, http.NoBody) + req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, apiURL, http.NoBody) if err != nil { panic(err) } @@ -210,7 +211,7 @@ func CreateAnIndexInSplunk(index, indexType string) { TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, } client := &http.Client{Transport: tr} - req, err := http.NewRequest(http.MethodPost, indexURL, strings.NewReader(data.Encode())) + req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, indexURL, strings.NewReader(data.Encode())) if err != nil { logger.Printf("Error while preparing POST request") panic(err) diff --git a/exporter/zipkinexporter/zipkin_test.go b/exporter/zipkinexporter/zipkin_test.go index f60d46e7ce973..9d3e284dc7115 100644 --- a/exporter/zipkinexporter/zipkin_test.go +++ b/exporter/zipkinexporter/zipkin_test.go @@ -5,6 +5,7 @@ package zipkinexporter import ( "bytes" + "context" "fmt" "io" "net/http" @@ -78,7 +79,10 @@ func TestZipkinExporter_roundtripJSON(t *testing.T) { t.Cleanup(func() { require.NoError(t, zi.Shutdown(t.Context())) }) // Let the receiver receive "uploaded Zipkin spans from a Java client application" - _, err = http.Post("http://"+addr, "application/json", strings.NewReader(zipkinSpansJSONJavaLibrary)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://"+addr, strings.NewReader(zipkinSpansJSONJavaLibrary)) + require.NoError(t, err) + req.Header.Set("Content-Type", "application/json") + _, err = http.DefaultClient.Do(req) require.NoError(t, err) // Use the mock zipkin reporter to ensure all expected spans in a single batch. Since Flush waits for @@ -176,7 +180,7 @@ func (r *mockZipkinReporter) Flush() error { return err } - req, err := http.NewRequest(http.MethodPost, r.url, bytes.NewReader(body)) + req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, r.url, bytes.NewReader(body)) if err != nil { return err } @@ -327,7 +331,8 @@ func TestZipkinExporter_roundtripProto(t *testing.T) { t.Cleanup(func() { require.NoError(t, zi.Shutdown(t.Context())) }) // Let the receiver receive "uploaded Zipkin spans from a Java client application" - _, _ = http.Post("http://"+addr, "", strings.NewReader(zipkinSpansJSONJavaLibrary)) + req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://"+addr, strings.NewReader(zipkinSpansJSONJavaLibrary)) + _, _ = http.DefaultClient.Do(req) // Use the mock zipkin reporter to ensure all expected spans in a single batch. Since Flush waits for // server response there is no need for further synchronization. diff --git a/extension/awsproxy/factory_test.go b/extension/awsproxy/factory_test.go index c58758745dc5c..8f41bf64f4d49 100644 --- a/extension/awsproxy/factory_test.go +++ b/extension/awsproxy/factory_test.go @@ -77,10 +77,12 @@ func TestFactory_Create(t *testing.T) { var resp *http.Response require.Eventually(t, func() bool { - resp, err = http.Post( - "http://"+address+"/GetSamplingRules", - "application/json", - strings.NewReader(`{"NextToken": null}`)) + req, err1 := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://"+address+"/GetSamplingRules", strings.NewReader(`{"NextToken": null}`)) + if err1 != nil { + return false + } + req.Header.Set("Content-Type", "application/json") + resp, err = http.DefaultClient.Do(req) return err == nil }, 3*time.Second, 10*time.Millisecond) diff --git a/extension/datadogextension/integration_test.go b/extension/datadogextension/integration_test.go index d744e81162c3f..acd7f2109359e 100644 --- a/extension/datadogextension/integration_test.go +++ b/extension/datadogextension/integration_test.go @@ -287,7 +287,7 @@ func TestFullOtelCollectorPayloadIntegration(t *testing.T) { // Step 5: Simulate sending payload (in a real scenario, this would use serializer.SendEvents or similar) // For this test, we simulate the HTTP request that would be made client := &http.Client{Timeout: 5 * time.Second} - req, err := http.NewRequest(http.MethodPost, backendURL+"/api/v1/otel_collector", http.NoBody) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, backendURL+"/api/v1/otel_collector", http.NoBody) require.NoError(t, err) req.Header.Set("Content-Type", "application/json") diff --git a/extension/datadogextension/internal/httpserver/httpserver_test.go b/extension/datadogextension/internal/httpserver/httpserver_test.go index 339cceb9fd086..6c576ed9bc95e 100644 --- a/extension/datadogextension/internal/httpserver/httpserver_test.go +++ b/extension/datadogextension/internal/httpserver/httpserver_test.go @@ -469,9 +469,12 @@ func TestServerStop(t *testing.T) { if tt.simulateSlowStop { cancel() - resp, err := http.Get("http://" + srv.server.Addr + "/block") + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://"+srv.server.Addr+"/block", http.NoBody) if err == nil { - _ = resp.Body.Close() + resp, err := http.DefaultClient.Do(req) + if err == nil { + _ = resp.Body.Close() + } } } } diff --git a/extension/healthcheckextension/healthcheckextension_test.go b/extension/healthcheckextension/healthcheckextension_test.go index b3ce8db38844e..361beb2be4eaf 100644 --- a/extension/healthcheckextension/healthcheckextension_test.go +++ b/extension/healthcheckextension/healthcheckextension_test.go @@ -195,7 +195,9 @@ func TestHealthCheckExtensionUsage(t *testing.T) { require.NoError(t, ts.step(hcExt)) } - resp, err := client.Get(url) + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, url, http.NoBody) + require.NoError(t, err) + resp, err := client.Do(req) require.NoError(t, err) if ts.expectedStatusCode != 0 { diff --git a/extension/healthcheckextension/integration_test.go b/extension/healthcheckextension/integration_test.go index 4d1b167951f23..9455b0a1c00ec 100644 --- a/extension/healthcheckextension/integration_test.go +++ b/extension/healthcheckextension/integration_test.go @@ -30,7 +30,9 @@ func Test_SimpleHealthCheck(t *testing.T) { t.Cleanup(func() { require.NoError(t, e.Shutdown(t.Context())) }) - resp, err := http.DefaultClient.Get(fmt.Sprintf("http://localhost:%d/", port)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, fmt.Sprintf("http://localhost:%d/", port), http.NoBody) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) require.NoError(t, err) assert.Equal(t, "503 Service Unavailable", resp.Status) var buf bytes.Buffer @@ -39,7 +41,9 @@ func Test_SimpleHealthCheck(t *testing.T) { assert.JSONEq(t, `{"status":"Server not available","upSince":"0001-01-01T00:00:00Z","uptime":""}`, buf.String()) err = e.(*healthCheckExtension).Ready() require.NoError(t, err) - resp, err = http.DefaultClient.Get(fmt.Sprintf("http://localhost:%d/", port)) + req2, err := http.NewRequestWithContext(t.Context(), http.MethodGet, fmt.Sprintf("http://localhost:%d/", port), http.NoBody) + require.NoError(t, err) + resp, err = http.DefaultClient.Do(req2) require.NoError(t, err) assert.Equal(t, "200 OK", resp.Status) buf.Reset() diff --git a/extension/httpforwarderextension/extension_test.go b/extension/httpforwarderextension/extension_test.go index 68abde6def2ad..33fb4b62afe24 100644 --- a/extension/httpforwarderextension/extension_test.go +++ b/extension/httpforwarderextension/extension_test.go @@ -274,7 +274,7 @@ func TestExtension(t *testing.T) { } func httpRequest(t *testing.T, args clientRequestArgs) *http.Request { - r, err := http.NewRequest(args.method, args.url, io.NopCloser(strings.NewReader(args.body))) + r, err := http.NewRequestWithContext(t.Context(), args.method, args.url, io.NopCloser(strings.NewReader(args.body))) require.NoError(t, err) for k, v := range args.headers { diff --git a/extension/jaegerremotesampling/extension_test.go b/extension/jaegerremotesampling/extension_test.go index 61d6a8684fd9f..eecfde1a507ef 100644 --- a/extension/jaegerremotesampling/extension_test.go +++ b/extension/jaegerremotesampling/extension_test.go @@ -118,7 +118,9 @@ func TestRemote(t *testing.T) { // make test case defined number of calls for i := 0; i < tc.performedClientCallCount; i++ { - resp, err := http.Get("http://127.0.0.1:5778/sampling?service=foo") + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://127.0.0.1:5778/sampling?service=foo", http.NoBody) + assert.NoError(t, err) + resp, err := http.DefaultClient.Do(req) assert.NoError(t, err) assert.Equal(t, 200, resp.StatusCode) assert.NoError(t, resp.Body.Close()) diff --git a/extension/jaegerremotesampling/internal/server/http/http_test.go b/extension/jaegerremotesampling/internal/server/http/http_test.go index 56543ec968704..d361398ad6959 100644 --- a/extension/jaegerremotesampling/internal/server/http/http_test.go +++ b/extension/jaegerremotesampling/internal/server/http/http_test.go @@ -72,8 +72,10 @@ func TestEndpointsAreWired(t *testing.T) { srv.Close() }() + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, fmt.Sprintf("%s%s?service=foo", srv.URL, tC.endpoint), http.NoBody) + require.NoError(t, err) // test - resp, err := srv.Client().Get(fmt.Sprintf("%s%s?service=foo", srv.URL, tC.endpoint)) + resp, err := srv.Client().Do(req) require.NoError(t, err) // verify diff --git a/extension/oauth2clientauthextension/extension_test.go b/extension/oauth2clientauthextension/extension_test.go index 473f1e87b5596..fe380c90e615f 100644 --- a/extension/oauth2clientauthextension/extension_test.go +++ b/extension/oauth2clientauthextension/extension_test.go @@ -309,7 +309,7 @@ func TestFailContactingOAuth(t *testing.T) { Transport: roundTripper, } - req, err := http.NewRequest(http.MethodPost, "http://example.com/", http.NoBody) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://example.com/", http.NoBody) require.NoError(t, err) _, err = client.Do(req) assert.ErrorIs(t, err, errFailedToGetSecurityToken) diff --git a/extension/opampextension/auth.go b/extension/opampextension/auth.go index d814cee09f6ee..6bd20325b6b23 100644 --- a/extension/opampextension/auth.go +++ b/extension/opampextension/auth.go @@ -5,6 +5,7 @@ package opampextension // import "github.com/open-telemetry/opentelemetry-collec import ( "bytes" + "context" "fmt" "io" "net/http" @@ -61,7 +62,7 @@ func makeHeadersFunc(logger *zap.Logger, serverCfg *OpAMPServer, host component. // This is a workaround while websocket authentication is being worked on. // Currently, we are waiting on the auth module to be stabilized. // See for more info: https://github.com/open-telemetry/opentelemetry-collector/issues/10864 - dummyReq, err := http.NewRequest(http.MethodGet, "http://example.com", http.NoBody) + dummyReq, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://example.com", http.NoBody) if err != nil { logger.Error("Failed to create dummy request for authentication.", zap.Error(err)) return h diff --git a/extension/pprofextension/pprofextension_test.go b/extension/pprofextension/pprofextension_test.go index 2516266f0f44b..bd1192167c733 100644 --- a/extension/pprofextension/pprofextension_test.go +++ b/extension/pprofextension/pprofextension_test.go @@ -39,8 +39,10 @@ func TestPerformanceProfilerExtensionUsage(t *testing.T) { _, pprofPort, err := net.SplitHostPort(config.TCPAddr.Endpoint) require.NoError(t, err) + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://localhost:"+pprofPort+"/debug/pprof/", http.NoBody) + require.NoError(t, err) client := &http.Client{} - resp, err := client.Get("http://localhost:" + pprofPort + "/debug/pprof") + resp, err := client.Do(req) require.NoError(t, err) defer resp.Body.Close() diff --git a/extension/sigv4authextension/extension_test.go b/extension/sigv4authextension/extension_test.go index 73d02ca554bda..3aaf064d4b394 100644 --- a/extension/sigv4authextension/extension_test.go +++ b/extension/sigv4authextension/extension_test.go @@ -131,10 +131,10 @@ func TestGetCredsProviderFromWebIdentityConfig(t *testing.T) { } func TestCloneRequest(t *testing.T) { - req1, err := http.NewRequest(http.MethodGet, "https://example.com", http.NoBody) + req1, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://example.com", http.NoBody) assert.NoError(t, err) - req2, err := http.NewRequest(http.MethodGet, "https://example.com", http.NoBody) + req2, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://example.com", http.NoBody) assert.NoError(t, err) req2.Header.Add("Header1", "val1") diff --git a/extension/sigv4authextension/signingroundtripper_test.go b/extension/sigv4authextension/signingroundtripper_test.go index ae8db048f6fd7..7e0796a2d4596 100644 --- a/extension/sigv4authextension/signingroundtripper_test.go +++ b/extension/sigv4authextension/signingroundtripper_test.go @@ -79,7 +79,7 @@ func TestRoundTrip(t *testing.T) { assert.NoError(t, err) newBody := strings.NewReader(body) - req, err := http.NewRequest(http.MethodPost, serverURL.String(), newBody) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, serverURL.String(), newBody) assert.NoError(t, err) res, err := rt.RoundTrip(req) @@ -95,25 +95,25 @@ func TestRoundTrip(t *testing.T) { } func TestInferServiceAndRegion(t *testing.T) { - req1, err := http.NewRequest(http.MethodGet, "https://example.com", http.NoBody) + req1, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://example.com", http.NoBody) assert.NoError(t, err) - req2, err := http.NewRequest(http.MethodGet, "https://aps-workspaces.us-east-1.amazonaws.com/workspaces/ws-XXX/api/v1/remote_write", http.NoBody) + req2, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://aps-workspaces.us-east-1.amazonaws.com/workspaces/ws-XXX/api/v1/remote_write", http.NoBody) assert.NoError(t, err) - req3, err := http.NewRequest(http.MethodGet, "https://search-my-domain.us-east-1.es.amazonaws.com/_search?q=house", http.NoBody) + req3, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://search-my-domain.us-east-1.es.amazonaws.com/_search?q=house", http.NoBody) assert.NoError(t, err) - req4, err := http.NewRequest(http.MethodGet, "https://example.com", http.NoBody) + req4, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://example.com", http.NoBody) assert.NoError(t, err) - req5, err := http.NewRequest(http.MethodGet, "https://aps-workspaces.us-east-1.amazonaws.com/workspaces/ws-XXX/api/v1/remote_write", http.NoBody) + req5, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://aps-workspaces.us-east-1.amazonaws.com/workspaces/ws-XXX/api/v1/remote_write", http.NoBody) assert.NoError(t, err) - req6, err := http.NewRequest(http.MethodGet, "https://logs.us-east-1.amazonaws.com/v1/logs", http.NoBody) + req6, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://logs.us-east-1.amazonaws.com/v1/logs", http.NoBody) assert.NoError(t, err) - req7, err := http.NewRequest(http.MethodGet, "https://xray.us-east-1.amazonaws.com/v1/traces", http.NoBody) + req7, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://xray.us-east-1.amazonaws.com/v1/traces", http.NoBody) assert.NoError(t, err) tests := []struct { @@ -192,13 +192,13 @@ func TestInferServiceAndRegion(t *testing.T) { } func TestHashPayload(t *testing.T) { - req1, err := http.NewRequest(http.MethodGet, "https://example.com", http.NoBody) + req1, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://example.com", http.NoBody) assert.NoError(t, err) - req2, err := http.NewRequest(http.MethodGet, "https://example.com", bytes.NewReader([]byte("This is a test."))) + req2, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://example.com", bytes.NewReader([]byte("This is a test."))) assert.NoError(t, err) - req3, err := http.NewRequest(http.MethodGet, "https://example.com", http.NoBody) + req3, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "https://example.com", http.NoBody) assert.NoError(t, err) req3.GetBody = func() (io.ReadCloser, error) { return nil, errors.New("this will always fail") } diff --git a/extension/solarwindsapmsettingsextension/extension.go b/extension/solarwindsapmsettingsextension/extension.go index 9428ca6f7adaa..cd0e50dcb5af2 100644 --- a/extension/solarwindsapmsettingsextension/extension.go +++ b/extension/solarwindsapmsettingsextension/extension.go @@ -80,7 +80,7 @@ func (extension *solarwindsapmSettingsExtension) Start(_ context.Context, host c if err != nil { return err } - extension.request, err = http.NewRequest(http.MethodGet, "https://"+extension.config.Endpoint+"/v1/settings/"+serviceName+"/"+hostname, http.NoBody) + extension.request, err = http.NewRequestWithContext(context.Background(), http.MethodGet, "https://"+extension.config.Endpoint+"/v1/settings/"+serviceName+"/"+hostname, http.NoBody) if err != nil { return err } diff --git a/extension/solarwindsapmsettingsextension/extension_test.go b/extension/solarwindsapmsettingsextension/extension_test.go index 199a30109eefd..cf550a4ea286d 100644 --- a/extension/solarwindsapmsettingsextension/extension_test.go +++ b/extension/solarwindsapmsettingsextension/extension_test.go @@ -165,7 +165,7 @@ func TestRefresh(t *testing.T) { observedZapCore, observedLogs := observer.New(zap.InfoLevel) settings := newNopSettings() settings.Logger = zap.New(observedZapCore) - mockRequest, err := http.NewRequest(http.MethodGet, "http://mock", http.NoBody) + mockRequest, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://mock", http.NoBody) require.NoError(t, err) settingsExtension := &solarwindsapmSettingsExtension{ config: &Config{ diff --git a/internal/aws/ecsutil/client.go b/internal/aws/ecsutil/client.go index 8fac85b16fda2..a87cdf86b27ad 100644 --- a/internal/aws/ecsutil/client.go +++ b/internal/aws/ecsutil/client.go @@ -112,7 +112,7 @@ func (c *clientImpl) Get(path string) ([]byte, error) { func (c *clientImpl) buildReq(path string) (*http.Request, error) { url := c.baseURL.String() + path - req, err := http.NewRequest(http.MethodGet, url, http.NoBody) + req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, url, http.NoBody) if err != nil { return nil, err } diff --git a/internal/aws/xray/testdata/sampleserver/sample.go b/internal/aws/xray/testdata/sampleserver/sample.go index 3d4d5b54c72b3..25c3d0a9a1d0e 100644 --- a/internal/aws/xray/testdata/sampleserver/sample.go +++ b/internal/aws/xray/testdata/sampleserver/sample.go @@ -4,6 +4,7 @@ package main import ( + "context" "net/http" "time" @@ -32,7 +33,11 @@ func main() { }() time.Sleep(time.Second) - resp, err := http.Get("http://localhost:8000") + req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://localhost:8000", http.NoBody) + if err != nil { + panic(err) + } + resp, err := http.DefaultClient.Do(req) if err != nil { panic(err) } diff --git a/internal/datadog/hostmetadata/metadata.go b/internal/datadog/hostmetadata/metadata.go index 9421bb24374ef..476e1f47ef900 100644 --- a/internal/datadog/hostmetadata/metadata.go +++ b/internal/datadog/hostmetadata/metadata.go @@ -113,7 +113,7 @@ func (p *pusher) pushMetadata(hm payload.HostMetadata) error { return fmt.Errorf("error closing gzip writer: %w", err) } - req, err := http.NewRequest(http.MethodPost, path, &buf) + req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, path, &buf) if err != nil { return fmt.Errorf("error creating metadata request: %w", err) } diff --git a/internal/healthcheck/extension_test.go b/internal/healthcheck/extension_test.go index 1551778827077..9977a6436c6d8 100644 --- a/internal/healthcheck/extension_test.go +++ b/internal/healthcheck/extension_test.go @@ -120,13 +120,17 @@ func TestNotifyConfig(t *testing.T) { var resp *http.Response - resp, err = client.Get(url) + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, url, http.NoBody) + require.NoError(t, err) + resp, err = client.Do(req) require.NoError(t, err) assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode) require.NoError(t, ext.NotifyConfig(t.Context(), confMap)) - resp, err = client.Get(url) + req, err = http.NewRequestWithContext(t.Context(), http.MethodGet, url, http.NoBody) + require.NoError(t, err) + resp, err = client.Do(req) require.NoError(t, err) assert.Equal(t, http.StatusOK, resp.StatusCode) diff --git a/internal/healthcheck/internal/http/server_test.go b/internal/healthcheck/internal/http/server_test.go index b30399c6c8bda..038b882698795 100644 --- a/internal/healthcheck/internal/http/server_test.go +++ b/internal/healthcheck/internal/http/server_test.go @@ -2971,12 +2971,16 @@ func TestStatus(t *testing.T) { if ts.eventually { assert.EventuallyWithT(t, func(tt *assert.CollectT) { - resp, err = client.Get(stepURL) + req, err1 := http.NewRequestWithContext(t.Context(), http.MethodGet, stepURL, http.NoBody) + require.NoError(tt, err1) + resp, err = client.Do(req) require.NoError(tt, err) assert.Equal(tt, ts.expectedStatusCode, resp.StatusCode) }, time.Second, 10*time.Millisecond) } else { - resp, err = client.Get(stepURL) + req, err1 := http.NewRequestWithContext(t.Context(), http.MethodGet, stepURL, http.NoBody) + require.NoError(t, err1) + resp, err = client.Do(req) require.NoError(t, err) assert.Equal(t, ts.expectedStatusCode, resp.StatusCode) } @@ -3132,7 +3136,10 @@ func TestConfig(t *testing.T) { tc.setup() } - resp, err := client.Get(url) + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, url, http.NoBody) + require.NoError(t, err) + + resp, err := client.Do(req) require.NoError(t, err) assert.Equal(t, tc.expectedStatusCode, resp.StatusCode) diff --git a/internal/kubelet/client.go b/internal/kubelet/client.go index 8c0dcf2a00c46..aeeef3ac34660 100644 --- a/internal/kubelet/client.go +++ b/internal/kubelet/client.go @@ -4,6 +4,7 @@ package kubelet // import "github.com/open-telemetry/opentelemetry-collector-contrib/internal/kubelet" import ( + "context" "crypto/tls" "crypto/x509" "fmt" @@ -298,7 +299,7 @@ func (c *clientImpl) buildReq(p string) (*http.Request, error) { if err != nil { return nil, err } - req, err := http.NewRequest(http.MethodGet, reqURL, http.NoBody) + req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, reqURL, http.NoBody) if err != nil { return nil, err } diff --git a/receiver/apachereceiver/integration_test.go b/receiver/apachereceiver/integration_test.go index fb1ccefca89c0..81c7d966c4c1c 100644 --- a/receiver/apachereceiver/integration_test.go +++ b/receiver/apachereceiver/integration_test.go @@ -81,7 +81,11 @@ func (waitStrategy) WaitUntilReady(ctx context.Context, st wait.StrategyTarget) case <-time.After(5 * time.Second): return errors.New("server startup problem") case <-time.After(100 * time.Millisecond): - resp, err := http.Get(fmt.Sprintf("http://%s:%s/server-status?auto", hostname, port.Port())) + req, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("http://%s:%s/server-status?auto", hostname, port.Port()), http.NoBody) + if err != nil { + continue + } + resp, err := http.DefaultClient.Do(req) if err != nil { continue } diff --git a/receiver/apachereceiver/scraper.go b/receiver/apachereceiver/scraper.go index 91b140f815176..2d6f68eeaad58 100644 --- a/receiver/apachereceiver/scraper.go +++ b/receiver/apachereceiver/scraper.go @@ -147,7 +147,11 @@ func addPartialIfError(errs *scrapererror.ScrapeErrors, err error) { // GetStats collects metric stats by making a get request at an endpoint. func (r *apacheScraper) GetStats() (string, error) { - resp, err := r.httpClient.Get(r.cfg.Endpoint) + req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, r.cfg.Endpoint, http.NoBody) + if err != nil { + return "", err + } + resp, err := r.httpClient.Do(req) if err != nil { return "", err } diff --git a/receiver/apachesparkreceiver/client.go b/receiver/apachesparkreceiver/client.go index 01f965609a6b6..d909bb48104e0 100644 --- a/receiver/apachesparkreceiver/client.go +++ b/receiver/apachesparkreceiver/client.go @@ -166,7 +166,7 @@ func (c *apacheSparkClient) JobStats(appID string) ([]models.Job, error) { func (c *apacheSparkClient) buildReq(path string) (*http.Request, error) { url := c.cfg.Endpoint + path - req, err := http.NewRequest(http.MethodGet, url, http.NoBody) + req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, url, http.NoBody) if err != nil { return nil, err } diff --git a/receiver/cloudflarereceiver/fuzz_test.go b/receiver/cloudflarereceiver/fuzz_test.go index 8bc12d0ca77dd..2e369ff6bf561 100644 --- a/receiver/cloudflarereceiver/fuzz_test.go +++ b/receiver/cloudflarereceiver/fuzz_test.go @@ -15,7 +15,7 @@ import ( func FuzzHandleReq(f *testing.F) { f.Fuzz(func(t *testing.T, reqBody []byte, gZip bool) { - req, err := http.NewRequest(http.MethodPost, "http://example.com", bytes.NewReader(reqBody)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://example.com", bytes.NewReader(reqBody)) if err != nil { t.Skip() } diff --git a/receiver/cloudflarereceiver/logs_integration_test.go b/receiver/cloudflarereceiver/logs_integration_test.go index 5de10d6a567a2..9712ea467995d 100644 --- a/receiver/cloudflarereceiver/logs_integration_test.go +++ b/receiver/cloudflarereceiver/logs_integration_test.go @@ -83,7 +83,7 @@ func TestReceiverTLSIntegration(t *testing.T) { payload, err := os.ReadFile(filepath.Join("testdata", "sample-payloads", fmt.Sprintf("%s.txt", payloadName))) require.NoError(t, err) - req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("https://localhost:%s", testPort), bytes.NewBuffer(payload)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, fmt.Sprintf("https://localhost:%s", testPort), bytes.NewBuffer(payload)) require.NoError(t, err) client, err := clientWithCert(filepath.Join("testdata", "cert", "ca.crt")) diff --git a/receiver/collectdreceiver/receiver_test.go b/receiver/collectdreceiver/receiver_test.go index e441c8f481126..3f1591a4b048e 100644 --- a/receiver/collectdreceiver/receiver_test.go +++ b/receiver/collectdreceiver/receiver_test.go @@ -163,7 +163,8 @@ func TestCollectDServer(t *testing.T) { for _, tt := range testCases { t.Run(tt.Name, func(t *testing.T) { sink.Reset() - req, err := http.NewRequest( + req, err := http.NewRequestWithContext( + t.Context(), tt.HTTPMethod, "http://"+config.Endpoint+"?"+tt.QueryParams, bytes.NewBuffer([]byte(tt.RequestBody)), diff --git a/receiver/couchdbreceiver/client.go b/receiver/couchdbreceiver/client.go index 9f02bc4228b65..dbcd3aed91c1f 100644 --- a/receiver/couchdbreceiver/client.go +++ b/receiver/couchdbreceiver/client.go @@ -95,7 +95,7 @@ func (c *couchDBClient) GetStats(nodeName string) (map[string]any, error) { func (c *couchDBClient) buildReq(path string) (*http.Request, error) { url := c.cfg.Endpoint + path - req, err := http.NewRequest(http.MethodGet, url, http.NoBody) + req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, url, http.NoBody) if err != nil { return nil, err } diff --git a/receiver/datadogreceiver/internal/translator/series_test.go b/receiver/datadogreceiver/internal/translator/series_test.go index ad83e40b88ff3..88e98118a46aa 100644 --- a/receiver/datadogreceiver/internal/translator/series_test.go +++ b/receiver/datadogreceiver/internal/translator/series_test.go @@ -77,7 +77,7 @@ func TestHandleMetricsPayloadV2(t *testing.T) { pb, err := tt.metricsPayload.Marshal() require.NoError(t, err) - req, err := http.NewRequest(http.MethodPost, "/api/v2/series", io.NopCloser(bytes.NewReader(pb))) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "/api/v2/series", io.NopCloser(bytes.NewReader(pb))) require.NoError(t, err) mt := createMetricsTranslator() series, err := mt.HandleSeriesV2Payload(req) diff --git a/receiver/datadogreceiver/internal/translator/sketches_test.go b/receiver/datadogreceiver/internal/translator/sketches_test.go index 7603e80efb7fc..3f40e6c635c5d 100644 --- a/receiver/datadogreceiver/internal/translator/sketches_test.go +++ b/receiver/datadogreceiver/internal/translator/sketches_test.go @@ -140,7 +140,7 @@ func TestHandleSketchPayload(t *testing.T) { pb, err := tt.sketchPayload.Marshal() require.NoError(t, err) - req, err := http.NewRequest(http.MethodPost, "/api/beta/sketches", io.NopCloser(bytes.NewReader(pb))) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "/api/beta/sketches", io.NopCloser(bytes.NewReader(pb))) require.NoError(t, err) mt := createMetricsTranslator() diff --git a/receiver/datadogreceiver/internal/translator/traces_translator_test.go b/receiver/datadogreceiver/internal/translator/traces_translator_test.go index 4776bb9c2b588..93e4586998e1d 100644 --- a/receiver/datadogreceiver/internal/translator/traces_translator_test.go +++ b/receiver/datadogreceiver/internal/translator/traces_translator_test.go @@ -90,7 +90,7 @@ func TestTracePayloadV05Unmarshalling(t *testing.T) { assert.NoError(t, err) require.NoError(t, traces.UnmarshalMsgDictionary(payload), "Must not error when marshaling content") - req, _ := http.NewRequest(http.MethodPost, "/v0.5/traces", io.NopCloser(bytes.NewReader(payload))) + req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/v0.5/traces", io.NopCloser(bytes.NewReader(payload))) tracePayloads, _ := HandleTracesPayload(req) assert.Len(t, tracePayloads, 1, "Expected one translated payload") @@ -132,7 +132,7 @@ func TestTracePayloadV07Unmarshalling(t *testing.T) { } var reqBytes []byte bytez, _ := apiPayload.MarshalMsg(reqBytes) - req, _ := http.NewRequest(http.MethodPost, "/v0.7/traces", io.NopCloser(bytes.NewReader(bytez))) + req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/v0.7/traces", io.NopCloser(bytes.NewReader(bytez))) translatedPayloads, _ := HandleTracesPayload(req) assert.Len(t, translatedPayloads, 1, "Expected one translated payload") @@ -168,7 +168,7 @@ func TestTracePayloadApiV02Unmarshalling(t *testing.T) { agentPayload := agentPayloadFromTraces(&traces) bytez, _ := proto.Marshal(&agentPayload) - req, _ := http.NewRequest(http.MethodPost, "/api/v0.2/traces", io.NopCloser(bytes.NewReader(bytez))) + req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/api/v0.2/traces", io.NopCloser(bytes.NewReader(bytez))) translatedPayloads, _ := HandleTracesPayload(req) assert.Len(t, translatedPayloads, 2, "Expected two translated payload") @@ -207,7 +207,7 @@ func agentPayloadFromTraces(traces *pb.Traces) (agentPayload pb.AgentPayload) { func TestUpsertHeadersAttributes(t *testing.T) { // Test case 1: Datadog-Meta-Tracer-Version is present in headers - req1, _ := http.NewRequest(http.MethodGet, "http://example.com", http.NoBody) + req1, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://example.com", http.NoBody) req1.Header.Set(header.TracerVersion, "1.2.3") attrs1 := pcommon.NewMap() upsertHeadersAttributes(req1, attrs1) @@ -216,7 +216,7 @@ func TestUpsertHeadersAttributes(t *testing.T) { assert.Equal(t, "Datadog-1.2.3", val.Str()) // Test case 2: Datadog-Meta-Lang is present in headers with ".NET" - req2, _ := http.NewRequest(http.MethodGet, "http://example.com", http.NoBody) + req2, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://example.com", http.NoBody) req2.Header.Set(header.Lang, ".NET") attrs2 := pcommon.NewMap() upsertHeadersAttributes(req2, attrs2) diff --git a/receiver/datadogreceiver/receiver_test.go b/receiver/datadogreceiver/receiver_test.go index a1efbecb1c6ec..ef509450d4d3e 100644 --- a/receiver/datadogreceiver/receiver_test.go +++ b/receiver/datadogreceiver/receiver_test.go @@ -121,7 +121,8 @@ func TestDatadogServer(t *testing.T) { t.Run(tc.name, func(t *testing.T) { t.Parallel() - req, err := http.NewRequest( + req, err := http.NewRequestWithContext( + t.Context(), http.MethodPost, fmt.Sprintf(tc.endpoint, dd.(*datadogReceiver).address), tc.op, @@ -311,7 +312,8 @@ func TestDatadogInfoEndpoint(t *testing.T) { require.NoError(t, dd.Shutdown(ctx), "Must not error shutting down") }() - req, err := http.NewRequest( + req, err := http.NewRequestWithContext( + t.Context(), http.MethodPost, fmt.Sprintf("http://%s/info", dd.(*datadogReceiver).address), http.NoBody, @@ -362,7 +364,8 @@ func TestDatadogMetricsV1_EndToEnd(t *testing.T) { ] }`) - req, err := http.NewRequest( + req, err := http.NewRequestWithContext( + t.Context(), http.MethodPost, fmt.Sprintf("http://%s/api/v1/series", dd.(*datadogReceiver).address), io.NopCloser(bytes.NewReader(metricsPayloadV1)), @@ -443,7 +446,8 @@ func TestDatadogMetricsV2_EndToEnd(t *testing.T) { pb, err := metricsPayloadV2.Marshal() assert.NoError(t, err) - req, err := http.NewRequest( + req, err := http.NewRequestWithContext( + t.Context(), http.MethodPost, fmt.Sprintf("http://%s/api/v2/series", dd.(*datadogReceiver).address), io.NopCloser(bytes.NewReader(pb)), @@ -522,7 +526,8 @@ func TestDatadogMetricsV2_EndToEndJSON(t *testing.T) { ] }`) - req, err := http.NewRequest( + req, err := http.NewRequestWithContext( + t.Context(), http.MethodPost, fmt.Sprintf("http://%s/api/v2/series", dd.(*datadogReceiver).address), io.NopCloser(bytes.NewReader(metricsPayloadV2)), @@ -605,7 +610,8 @@ func TestDatadogSketches_EndToEnd(t *testing.T) { pb, err := sketchPayload.Marshal() assert.NoError(t, err) - req, err := http.NewRequest( + req, err := http.NewRequestWithContext( + t.Context(), http.MethodPost, fmt.Sprintf("http://%s/api/beta/sketches", dd.(*datadogReceiver).address), io.NopCloser(bytes.NewReader(pb)), @@ -709,7 +715,8 @@ func TestStats_EndToEnd(t *testing.T) { payload, err := clientStatsPayload.MarshalMsg(nil) assert.NoError(t, err) - req, err := http.NewRequest( + req, err := http.NewRequestWithContext( + t.Context(), http.MethodPost, fmt.Sprintf("http://%s/v0.6/stats", dd.(*datadogReceiver).address), io.NopCloser(bytes.NewReader(payload)), @@ -772,7 +779,8 @@ func TestDatadogServices_EndToEnd(t *testing.T) { } ]`) - req, err := http.NewRequest( + req, err := http.NewRequestWithContext( + t.Context(), http.MethodPost, fmt.Sprintf("http://%s/api/v1/check_run", dd.(*datadogReceiver).address), io.NopCloser(bytes.NewReader(servicesPayload)), diff --git a/receiver/faroreceiver/receiver_test.go b/receiver/faroreceiver/receiver_test.go index d9452536f7778..37954b449f7b9 100644 --- a/receiver/faroreceiver/receiver_test.go +++ b/receiver/faroreceiver/receiver_test.go @@ -85,7 +85,7 @@ func TestFaroReceiver_Start(t *testing.T) { contents, err := os.ReadFile(tc.payload) require.NoError(t, err) - req, err := http.NewRequest(http.MethodPost, server.URL+faroPath, bytes.NewBuffer(contents)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, server.URL+faroPath, bytes.NewBuffer(contents)) require.NoError(t, err) req.Header.Set("Content-Type", "application/json") diff --git a/receiver/haproxyreceiver/scraper.go b/receiver/haproxyreceiver/scraper.go index 74bd2d506f269..0307393325bc2 100644 --- a/receiver/haproxyreceiver/scraper.go +++ b/receiver/haproxyreceiver/scraper.go @@ -40,7 +40,11 @@ type haproxyScraper struct { func (s *haproxyScraper) scrape(ctx context.Context) (pmetric.Metrics, error) { var records []map[string]string if u, notURLerr := url.Parse(s.cfg.Endpoint); notURLerr == nil && strings.HasPrefix(u.Scheme, "http") { - resp, err := s.httpClient.Get(s.cfg.Endpoint + ";csv") + req, err := http.NewRequestWithContext(ctx, http.MethodGet, s.cfg.Endpoint+";csv", http.NoBody) + if err != nil { + return pmetric.NewMetrics(), err + } + resp, err := s.httpClient.Do(req) if err != nil { return pmetric.NewMetrics(), err } diff --git a/receiver/jaegerreceiver/trace_receiver_test.go b/receiver/jaegerreceiver/trace_receiver_test.go index 43c1f8e37d269..3ab8af21aa863 100644 --- a/receiver/jaegerreceiver/trace_receiver_test.go +++ b/receiver/jaegerreceiver/trace_receiver_test.go @@ -395,7 +395,7 @@ func sendToCollector(endpoint string, batch *jaegerthrift.Batch) error { if err != nil { return err } - req, err := http.NewRequest(http.MethodPost, endpoint, bytes.NewBuffer(buf)) + req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, endpoint, bytes.NewBuffer(buf)) if err != nil { return err } diff --git a/receiver/jmxreceiver/integration_test.go b/receiver/jmxreceiver/integration_test.go index b694af04285f0..b43e8d73aa8ba 100644 --- a/receiver/jmxreceiver/integration_test.go +++ b/receiver/jmxreceiver/integration_test.go @@ -79,7 +79,11 @@ func (suite *jmxIntegrationSuite) TearDownSuite() { } func downloadJMXJAR(t *testing.T, url string) (string, error) { - resp, err := http.Get(url) //nolint:gosec + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, url, http.NoBody) + if err != nil { + return "", err + } + resp, err := http.DefaultClient.Do(req) if err != nil { return "", err } diff --git a/receiver/libhoneyreceiver/receiver.go b/receiver/libhoneyreceiver/receiver.go index 8cd71538e127e..23ea5699b1291 100644 --- a/receiver/libhoneyreceiver/receiver.go +++ b/receiver/libhoneyreceiver/receiver.go @@ -137,7 +137,7 @@ func (r *libhoneyReceiver) registerLogConsumer(tc consumer.Logs) { func (r *libhoneyReceiver) handleAuth(resp http.ResponseWriter, req *http.Request) { r.settings.Logger.Debug("handling auth request", zap.String("auth_api", r.cfg.AuthAPI)) authURL := fmt.Sprintf("%s/1/auth", r.cfg.AuthAPI) - authReq, err := http.NewRequest(http.MethodGet, authURL, http.NoBody) + authReq, err := http.NewRequestWithContext(context.Background(), http.MethodGet, authURL, http.NoBody) if err != nil { errJSON, _ := json.Marshal(`{"error": "failed to create auth request"}`) writeResponse(resp, "json", http.StatusBadRequest, errJSON) diff --git a/receiver/lokireceiver/internal/fuzz_test.go b/receiver/lokireceiver/internal/fuzz_test.go index fd3c0df96e214..6bed922e5ffc9 100644 --- a/receiver/lokireceiver/internal/fuzz_test.go +++ b/receiver/lokireceiver/internal/fuzz_test.go @@ -11,7 +11,7 @@ import ( func FuzzParseRequest(f *testing.F) { f.Fuzz(func(t *testing.T, data []byte, headerType uint8) { - req, err := http.NewRequest(http.MethodPost, "http://example.com", bytes.NewReader(data)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://example.com", bytes.NewReader(data)) if err != nil { t.Skip() } diff --git a/receiver/lokireceiver/internal/push_test.go b/receiver/lokireceiver/internal/push_test.go index ac37507b87032..a7c60a6da9f89 100644 --- a/receiver/lokireceiver/internal/push_test.go +++ b/receiver/lokireceiver/internal/push_test.go @@ -7,6 +7,7 @@ import ( "bytes" "compress/flate" "compress/gzip" + "context" "net/http" "testing" "time" @@ -111,7 +112,7 @@ func TestParseRequest_ProtobufContentType(t *testing.T) { // Helper functions func createTestRequest(body, contentType, contentEncoding string) *http.Request { - req, _ := http.NewRequest(http.MethodPost, "/test", bytes.NewReader([]byte(body))) + req, _ := http.NewRequestWithContext(context.Background(), http.MethodPost, "/test", bytes.NewReader([]byte(body))) if contentType != "" { req.Header.Set("Content-Type", contentType) } diff --git a/receiver/lokireceiver/loki_test.go b/receiver/lokireceiver/loki_test.go index fbce390f907ce..53d1534aed289 100644 --- a/receiver/lokireceiver/loki_test.go +++ b/receiver/lokireceiver/loki_test.go @@ -39,7 +39,7 @@ import ( "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/lokireceiver/internal/metadata" ) -func sendToCollector(endpoint, contentType, contentEncoding string, body []byte) error { +func sendToCollector(ctx context.Context, endpoint, contentType, contentEncoding string, body []byte) error { var buf bytes.Buffer switch contentEncoding { @@ -70,7 +70,7 @@ func sendToCollector(endpoint, contentType, contentEncoding string, body []byte) } } - req, err := http.NewRequest(http.MethodPost, endpoint, &buf) + req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, &buf) if err != nil { return err } @@ -197,7 +197,7 @@ func TestSendingProtobufPushRequestToHTTPEndpoint(t *testing.T) { buf, err := proto.Marshal(tt.body) require.NoError(t, err) - require.NoError(t, sendToCollector(collectorAddr, tt.contentType, tt.contentEncoding, buf)) + require.NoError(t, sendToCollector(t.Context(), collectorAddr, tt.contentType, tt.contentEncoding, buf)) gotLogs := sink.AllLogs() require.NoError(t, plogtest.CompareLogs(tt.expected, gotLogs[i], plogtest.IgnoreObservedTimestamp())) }) @@ -316,7 +316,7 @@ func TestSendingPushRequestToHTTPEndpoint(t *testing.T) { _, port, _ := net.SplitHostPort(addr) collectorAddr := fmt.Sprintf("http://localhost:%s/loki/api/v1/push", port) - require.NoError(t, sendToCollector(collectorAddr, tt.contentType, tt.contentEncoding, tt.body), "sending logs to http endpoint shouldn't have been failed") + require.NoError(t, sendToCollector(t.Context(), collectorAddr, tt.contentType, tt.contentEncoding, tt.body), "sending logs to http endpoint shouldn't have been failed") gotLogs := sink.AllLogs() require.NoError(t, plogtest.CompareLogs(tt.expected, gotLogs[0], plogtest.IgnoreObservedTimestamp())) sink.Reset() @@ -447,7 +447,7 @@ func TestExpectedStatus(t *testing.T) { _, port, _ := net.SplitHostPort(httpAddr) collectorAddr := fmt.Sprintf("http://localhost:%s/loki/api/v1/push", port) - require.EqualError(t, sendToCollector(collectorAddr, "application/json", "", []byte(`{"streams": [{"stream": {"foo": "bar"},"values": [[ "1676888496000000000", "logline 1" ]]}]}`)), tt.expectedHTTPError) + require.EqualError(t, sendToCollector(t.Context(), collectorAddr, "application/json", "", []byte(`{"streams": [{"stream": {"foo": "bar"},"values": [[ "1676888496000000000", "logline 1" ]]}]}`)), tt.expectedHTTPError) }) } } diff --git a/receiver/mongodbatlasreceiver/alerts_integration_test.go b/receiver/mongodbatlasreceiver/alerts_integration_test.go index 29c77ed02626d..0aaecf6c138d5 100644 --- a/receiver/mongodbatlasreceiver/alerts_integration_test.go +++ b/receiver/mongodbatlasreceiver/alerts_integration_test.go @@ -80,7 +80,7 @@ func TestAlertsReceiver(t *testing.T) { payload, err := os.ReadFile(filepath.Join("testdata", "alerts", "sample-payloads", payloadName+".json")) require.NoError(t, err) - req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("http://localhost:%s", testPort), bytes.NewBuffer(payload)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, fmt.Sprintf("http://localhost:%s", testPort), bytes.NewBuffer(payload)) require.NoError(t, err) b64HMAC, err := calculateHMACb64(testSecret, payload) @@ -151,7 +151,7 @@ func TestAlertsReceiverTLS(t *testing.T) { payload, err := os.ReadFile(filepath.Join("testdata", "alerts", "sample-payloads", payloadName+".json")) require.NoError(t, err) - req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("https://localhost:%s", testPort), bytes.NewBuffer(payload)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, fmt.Sprintf("https://localhost:%s", testPort), bytes.NewBuffer(payload)) require.NoError(t, err) b64HMAC, err := calculateHMACb64(testSecret, payload) diff --git a/receiver/mongodbatlasreceiver/fuzz_test.go b/receiver/mongodbatlasreceiver/fuzz_test.go index ef3b3767f8ce3..ad6ca8c1f958e 100644 --- a/receiver/mongodbatlasreceiver/fuzz_test.go +++ b/receiver/mongodbatlasreceiver/fuzz_test.go @@ -18,7 +18,7 @@ import ( func FuzzHandleReq(f *testing.F) { f.Fuzz(func(t *testing.T, reqBody []byte, payloadSigHeader string) { - req, err := http.NewRequest(http.MethodPost, "http://example.com", bytes.NewReader(reqBody)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://example.com", bytes.NewReader(reqBody)) if err != nil { t.Skip() } diff --git a/receiver/prometheusreceiver/metricsreceiver_api_server_test.go b/receiver/prometheusreceiver/metricsreceiver_api_server_test.go index 414d8d138a42a..f611cdcc90bac 100644 --- a/receiver/prometheusreceiver/metricsreceiver_api_server_test.go +++ b/receiver/prometheusreceiver/metricsreceiver_api_server_test.go @@ -4,6 +4,7 @@ package prometheusreceiver import ( + "context" "encoding/json" "fmt" "io" @@ -76,7 +77,7 @@ func TestPrometheusAPIServer(t *testing.T) { require.NoError(t, receiver.Start(ctx, componenttest.NewNopHost())) t.Cleanup(func() { require.NoError(t, receiver.Shutdown(ctx)) - response, err := callAPI(endpoint, "/scrape_pools") + response, err := callAPI(t.Context(), endpoint, "/scrape_pools") require.Error(t, err) require.Nil(t, response) }) @@ -96,8 +97,12 @@ func TestPrometheusAPIServer(t *testing.T) { } } -func callAPI(endpoint, path string) (*apiResponse, error) { - resp, err := http.Get(fmt.Sprintf("http://%s/api/v1%s", endpoint, path)) +func callAPI(ctx context.Context, endpoint, path string) (*apiResponse, error) { + req, err := http.NewRequestWithContext(ctx, http.MethodGet, fmt.Sprintf("http://%s/api/v1%s", endpoint, path), http.NoBody) + if err != nil { + return nil, err + } + resp, err := http.DefaultClient.Do(req) if err != nil { return nil, err } @@ -117,7 +122,7 @@ func callAPI(endpoint, path string) (*apiResponse, error) { } func testScrapePools(t *testing.T, endpoint string) { - scrapePoolsResponse, err := callAPI(endpoint, "/scrape_pools") + scrapePoolsResponse, err := callAPI(t.Context(), endpoint, "/scrape_pools") assert.NoError(t, err) var scrapePools scrapePoolsData err = json.Unmarshal([]byte(scrapePoolsResponse.Data), &scrapePools) @@ -128,7 +133,7 @@ func testScrapePools(t *testing.T, endpoint string) { } func testTargets(t *testing.T, endpoint string) { - targetsResponse, err := callAPI(endpoint, "/targets") + targetsResponse, err := callAPI(t.Context(), endpoint, "/targets") assert.NoError(t, err) var targets v1.TargetsResult err = json.Unmarshal([]byte(targetsResponse.Data), &targets) @@ -144,7 +149,7 @@ func testTargets(t *testing.T, endpoint string) { } func testTargetsMetadata(t *testing.T, endpoint string) { - targetsMetadataResponse, err := callAPI(endpoint, "/targets/metadata?match_target={job=\"target1\"}") + targetsMetadataResponse, err := callAPI(t.Context(), endpoint, "/targets/metadata?match_target={job=\"target1\"}") assert.NoError(t, err) assert.NotNil(t, targetsMetadataResponse) @@ -161,7 +166,7 @@ func testTargetsMetadata(t *testing.T, endpoint string) { } func testPrometheusConfig(t *testing.T, endpoint string, receiver *pReceiver) { - prometheusConfigResponse, err := callAPI(endpoint, "/status/config") + prometheusConfigResponse, err := callAPI(t.Context(), endpoint, "/status/config") assert.NoError(t, err) var prometheusConfigResult v1.ConfigResult err = json.Unmarshal([]byte(prometheusConfigResponse.Data), &prometheusConfigResult) @@ -187,7 +192,7 @@ func testPrometheusConfig(t *testing.T, endpoint string, receiver *pReceiver) { } func testRuntimeInfo(t *testing.T, endpoint string) { - prometheusConfigResponse, err := callAPI(endpoint, "/status/runtimeinfo") + prometheusConfigResponse, err := callAPI(t.Context(), endpoint, "/status/runtimeinfo") assert.NoError(t, err) var runtimeInfo api_v1.RuntimeInfo err = json.Unmarshal([]byte(prometheusConfigResponse.Data), &runtimeInfo) @@ -199,7 +204,7 @@ func testRuntimeInfo(t *testing.T, endpoint string) { } func testBuildInfo(t *testing.T, endpoint string) { - prometheusConfigResponse, err := callAPI(endpoint, "/status/buildinfo") + prometheusConfigResponse, err := callAPI(t.Context(), endpoint, "/status/buildinfo") assert.NoError(t, err) var prometheusVersion api_v1.PrometheusVersion @@ -210,7 +215,7 @@ func testBuildInfo(t *testing.T, endpoint string) { } func testFlags(t *testing.T, endpoint string) { - prometheusConfigResponse, err := callAPI(endpoint, "/status/flags") + prometheusConfigResponse, err := callAPI(t.Context(), endpoint, "/status/flags") assert.NoError(t, err) var flagsMap map[string]string err = json.Unmarshal([]byte(prometheusConfigResponse.Data), &flagsMap) @@ -219,7 +224,9 @@ func testFlags(t *testing.T, endpoint string) { } func testMetricsEndpoint(t *testing.T, endpoint string) { - resp, err := http.Get(fmt.Sprintf("http://%s/metrics", endpoint)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, fmt.Sprintf("http://%s/metrics", endpoint), http.NoBody) + assert.NoError(t, err) + resp, err := http.DefaultClient.Do(req) assert.NoError(t, err) assert.NotNil(t, resp) defer resp.Body.Close() diff --git a/receiver/prometheusreceiver/targetallocator/manager.go b/receiver/prometheusreceiver/targetallocator/manager.go index 0f401669ed453..41e19de68747b 100644 --- a/receiver/prometheusreceiver/targetallocator/manager.go +++ b/receiver/prometheusreceiver/targetallocator/manager.go @@ -228,7 +228,11 @@ func getScrapeConfigsResponse(httpClient *http.Client, baseURL string) (map[stri return nil, err } - resp, err := httpClient.Get(scrapeConfigsURL) + req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, scrapeConfigsURL, http.NoBody) + if err != nil { + return nil, err + } + resp, err := httpClient.Do(req) if err != nil { return nil, err } diff --git a/receiver/prometheusremotewritereceiver/receiver_test.go b/receiver/prometheusremotewritereceiver/receiver_test.go index 942a8b42fa618..f552461f6f240 100644 --- a/receiver/prometheusremotewritereceiver/receiver_test.go +++ b/receiver/prometheusremotewritereceiver/receiver_test.go @@ -1579,11 +1579,10 @@ func TestTargetInfoWithMultipleRequests(t *testing.T) { err := pBuf.Marshal(req) assert.NoError(t, err) - resp, err := http.Post( - ts.URL, - fmt.Sprintf("application/x-protobuf;proto=%s", promconfig.RemoteWriteProtoMsgV2), - bytes.NewBuffer(pBuf.Bytes()), - ) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, ts.URL, bytes.NewBuffer(pBuf.Bytes())) + assert.NoError(t, err) + req.Header.Set("Content-Type", fmt.Sprintf("application/x-protobuf;proto=%s", promconfig.RemoteWriteProtoMsgV2)) + resp, err := http.DefaultClient.Do(req) assert.NoError(t, err) defer resp.Body.Close() @@ -1775,11 +1774,10 @@ func TestLRUCacheResourceMetrics(t *testing.T) { err := pBuf.Marshal(req) assert.NoError(t, err) - resp, err := http.Post( - ts.URL, - fmt.Sprintf("application/x-protobuf;proto=%s", promconfig.RemoteWriteProtoMsgV2), - bytes.NewBuffer(pBuf.Bytes()), - ) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, ts.URL, bytes.NewBuffer(pBuf.Bytes())) + assert.NoError(t, err) + req.Header.Set("Content-Type", fmt.Sprintf("application/x-protobuf;proto=%s", promconfig.RemoteWriteProtoMsgV2)) + resp, err := http.DefaultClient.Do(req) assert.NoError(t, err) body, err := io.ReadAll(resp.Body) diff --git a/receiver/signalfxreceiver/fuzz_test.go b/receiver/signalfxreceiver/fuzz_test.go index 0b638aac2df9e..e75d80637c59e 100644 --- a/receiver/signalfxreceiver/fuzz_test.go +++ b/receiver/signalfxreceiver/fuzz_test.go @@ -17,7 +17,7 @@ import ( func FuzzHandleDatapointReq(f *testing.F) { f.Fuzz(func(t *testing.T, reqBody []byte) { - req, err := http.NewRequest(http.MethodPost, "http://example.com", bytes.NewReader(reqBody)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://example.com", bytes.NewReader(reqBody)) if err != nil { t.Skip() } diff --git a/receiver/signalfxreceiver/receiver_test.go b/receiver/signalfxreceiver/receiver_test.go index 1a7bbeec26307..b52168042dd91 100644 --- a/receiver/signalfxreceiver/receiver_test.go +++ b/receiver/signalfxreceiver/receiver_test.go @@ -668,7 +668,7 @@ func Test_sfxReceiver_TLS(t *testing.T) { url := fmt.Sprintf("https://%s/v2/datapoint", addr) - req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(body)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, url, bytes.NewReader(body)) require.NoErrorf(t, err, "should have no errors with new request: %v", err) req.Header.Set("Content-Type", "application/x-protobuf") diff --git a/receiver/skywalkingreceiver/skywalking_receiver_test.go b/receiver/skywalkingreceiver/skywalking_receiver_test.go index ca8db73bbbaec..4612ac176c799 100644 --- a/receiver/skywalkingreceiver/skywalking_receiver_test.go +++ b/receiver/skywalkingreceiver/skywalking_receiver_test.go @@ -137,7 +137,7 @@ func TestHttpReception(t *testing.T) { require.NoError(t, err) require.NoError(t, mockSwReceiver.Start(t.Context(), componenttest.NewNopHost())) t.Cleanup(func() { require.NoError(t, mockSwReceiver.Shutdown(t.Context())) }) - req, err := http.NewRequest(http.MethodPost, "http://127.0.0.1:12800/v3/segments", bytes.NewBuffer(traceJSON)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://127.0.0.1:12800/v3/segments", bytes.NewBuffer(traceJSON)) require.NoError(t, err) req.Header.Set("Content-Type", "application/json") client := &http.Client{} diff --git a/receiver/splunkenterprisereceiver/client_test.go b/receiver/splunkenterprisereceiver/client_test.go index 56b4a1854ca0f..f3bc7d6ef7061 100644 --- a/receiver/splunkenterprisereceiver/client_test.go +++ b/receiver/splunkenterprisereceiver/client_test.go @@ -90,7 +90,7 @@ func TestClientCreateRequest(t *testing.T) { desc string sr *searchResponse client *splunkEntClient - expected *http.Request + expected func(t *testing.T) *http.Request }{ { desc: "First req, no jobid", @@ -98,15 +98,15 @@ func TestClientCreateRequest(t *testing.T) { search: "example search", }, client: client, - expected: func() *http.Request { + expected: func(t *testing.T) *http.Request { method := http.MethodPost path := "/services/search/jobs/" testEndpoint, _ := url.Parse("https://localhost:8089") url, _ := url.JoinPath(testEndpoint.String(), path) data := strings.NewReader("example search") - req, _ := http.NewRequest(method, url, data) + req, _ := http.NewRequestWithContext(t.Context(), method, url, data) return req - }(), + }, }, { desc: "Second req, jobID detected", @@ -115,14 +115,14 @@ func TestClientCreateRequest(t *testing.T) { Jobid: &testJobID, }, client: client, - expected: func() *http.Request { + expected: func(t *testing.T) *http.Request { method := http.MethodGet path := fmt.Sprintf("/services/search/jobs/%s/results", testJobID) testEndpoint, _ := url.Parse("https://localhost:8089") url, _ := url.JoinPath(testEndpoint.String(), path) - req, _ := http.NewRequest(method, url, http.NoBody) + req, _ := http.NewRequestWithContext(t.Context(), method, url, http.NoBody) return req - }(), + }, }, } @@ -130,11 +130,12 @@ func TestClientCreateRequest(t *testing.T) { t.Run(test.desc, func(t *testing.T) { req, err := test.client.createRequest(typeIdx, test.sr) require.NoError(t, err) + expected := test.expected(t) // have to test specific parts since individual fields are pointers - require.Equal(t, test.expected.URL, req.URL) - require.Equal(t, test.expected.Method, req.Method) - require.Equal(t, test.expected.Header, req.Header) - require.Equal(t, test.expected.Body, req.Body) + require.Equal(t, expected.URL, req.URL) + require.Equal(t, expected.Method, req.Method) + require.Equal(t, expected.Header, req.Header) + require.Equal(t, expected.Body, req.Body) }) } } @@ -168,7 +169,7 @@ func TestAPIRequestCreate(t *testing.T) { // build the expected request expectedURL := client.clients[typeIdx].endpoint.String() + "/test/endpoint" - expected, _ := http.NewRequest(http.MethodGet, expectedURL, http.NoBody) + expected, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, expectedURL, http.NoBody) require.Equal(t, expected.URL, req.URL) require.Equal(t, expected.Method, req.Method) diff --git a/receiver/splunkhecreceiver/fuzz_test.go b/receiver/splunkhecreceiver/fuzz_test.go index cc8162f0fe359..08e1308c6e674 100644 --- a/receiver/splunkhecreceiver/fuzz_test.go +++ b/receiver/splunkhecreceiver/fuzz_test.go @@ -17,7 +17,7 @@ import ( func FuzzHandleRawReq(f *testing.F) { f.Fuzz(func(t *testing.T, reqBody []byte) { - req, err := http.NewRequest(http.MethodPost, "http://example.com", bytes.NewReader(reqBody)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://example.com", bytes.NewReader(reqBody)) if err != nil { t.Skip() } diff --git a/receiver/webhookeventreceiver/fuzz_test.go b/receiver/webhookeventreceiver/fuzz_test.go index e954ff55b4381..c14e5ccb3834e 100644 --- a/receiver/webhookeventreceiver/fuzz_test.go +++ b/receiver/webhookeventreceiver/fuzz_test.go @@ -19,7 +19,7 @@ import ( func FuzzHandleReq(f *testing.F) { f.Fuzz(func(t *testing.T, reqBody []byte, useGzip bool) { - req, err := http.NewRequest(http.MethodPost, "http://example.com", bytes.NewReader(reqBody)) + req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://example.com", bytes.NewReader(reqBody)) if err != nil { t.Skip() }