Method send

utils/network/http_client.go:88–132

(request *HttpRequest, ctx context.Context)

}

func (c HttpClient) send(request *HttpRequest, ctx context.Context) (*HttpResponse, error) {
	transport := &http.Transport{
		Proxy:                 http.ProxyFromEnvironment,
		TLSClientConfig:       &tls.Config{InsecureSkipVerify: c.settings.Insecure}, //nolint:gosec // This is user configurable and disabled by default
		ResponseHeaderTimeout: c.settings.Timeout,
	}
	client := &http.Client{Transport: transport}

	responseChan := make(chan *HttpResponse)
	ctx, cancel := context.WithCancelCause(ctx)
	go func(client *http.Client, request *HttpRequest) {
		req, err := http.NewRequestWithContext(ctx, request.Method, request.URL, request.Body)
		if err != nil {
			cancel(fmt.Errorf("Error preparing request: %w", err))
			return
		}
		req.Header = request.Header
		for k, v := range c.settings.Header {
			req.Header.Set(k, v)
		}
		req.ContentLength = request.ContentLength

		resp, err := client.Do(req) //nolint:bodyclose // The response body needs to be closed by the caller to support streaming
		if err != nil {
			cancel(fmt.Errorf("Error sending request: %w", err))
			return
		}

		response := NewHttpResponse(
			resp.Status,
			resp.StatusCode,
			resp.Proto,
			resp.Header,
			resp.Body,
			resp.ContentLength)
		responseChan <- response
	}(client, request)

	select {
	case <-ctx.Done():
		return nil, fmt.Errorf("Error sending request: %w", context.Cause(ctx))
	case response := <-responseChan:
		return response, nil
	}
}

func (c HttpClient) logRequest(request *HttpRequest, body []byte) {
	reader := bytes.NewReader(c.truncate(body, loggingLimit))