http

Documentation

Index

• Constants
• Variables
• func CachedResponse(c Cache, req *http.Request) (resp *http.Response, err error)
• func CreateHttpErrorMessage(url string, body string, statusCode int) string
• func Date(respHeaders http.Header) (date time.Time, err error)
• func HttpErrorPropagatedRetryPolicy(ctx context.Context, resp *http.Response, err error) (bool, error)
• func NewHttpRetryClient(log *zap.Logger, maxRetries int) *retryablehttp.Client
• func SetCacheExpireHeader(headers http.Header)
• func SetCommonLoggingAttributes(ctx context.Context, c *gin.Context) (*zap.Logger, context.Context)
• func SignBody(secret, body []byte) []byte
• type Cache
• type ErrorDetail
• type MemoryCache
  • func NewMemoryCache() *MemoryCache
  • func (c *MemoryCache) Delete(key string)
  • func (c *MemoryCache) Get(key string) (resp []byte, ok bool)
  • func (c *MemoryCache) Set(key string, resp []byte)
• type Transport
  • func NewMemoryCacheTransport() *Transport
  • func NewTransport(c Cache) *Transport
  • func NewTransportLocalCacheTime(c Cache) *Transport
  • func (t *Transport) Client() *http.Client
  • func (t *Transport) RoundTrip(req *http.Request) (resp *http.Response, err error)
• type WebhookConfig
  • func (c *WebhookConfig) SendWebhook() error

Constants

const (

	// XFromCache is the header added to responses that are returned from the cache
	XFromCache           = "X-From-Cache"
	CacheExpireHeaderKey = "X-Cache-Expire"
)

const (
	RequestHeaderKey = "X-Request-Id"
)

Variables

var (
	CacheDirectory       = path.Join(os.TempDir(), fmt.Sprintf("%s-cache", settings.CliBinaryName))
	MaxCacheAgeInSeconds = 300
)

var ErrNoDateHeader = errors.New("no Date header")

ErrNoDateHeader indicates that the HTTP headers contained no Date header.

var (
	TraceHeaderKey = "X-TRACE"
)

Functions

func CachedResponse

func CachedResponse(c Cache, req *http.Request) (resp *http.Response, err error)

CachedResponse returns the cached http.Response for req if present, and nil otherwise.

func CreateHttpErrorMessage

func CreateHttpErrorMessage(url string, body string, statusCode int) string

func Date

func Date(respHeaders http.Header) (date time.Time, err error)

Date parses and returns the value of the Date header.

func HttpErrorPropagatedRetryPolicy

func HttpErrorPropagatedRetryPolicy(ctx context.Context, resp *http.Response, err error) (bool, error)

ErrorPropagatedRetryPolicy is the same as DefaultRetryPolicy, except it propagates errors back instead of returning nil. This allows you to inspect why it decided to retry or not.

func NewHttpRetryClient

func NewHttpRetryClient(log *zap.Logger, maxRetries int) *retryablehttp.Client

func SetCacheExpireHeader

func SetCacheExpireHeader(headers http.Header)

func SetCommonLoggingAttributes

func SetCommonLoggingAttributes(ctx context.Context, c *gin.Context) (*zap.Logger, context.Context)

func SignBody

func SignBody(secret, body []byte) []byte

signBody signs the body with the secret using HMAC-SHA256

Types

type Cache

type Cache interface {
	// Get returns the []byte representation of a cached response and a bool
	// set to true if the value isn't empty
	Get(key string) (responseBytes []byte, ok bool)
	// Set stores the []byte representation of a response against a key
	Set(key string, responseBytes []byte)
	// Delete removes the value associated with the key
	Delete(key string)
}

A Cache interface is used by the Transport to store and retrieve responses.

type ErrorDetail

type ErrorDetail struct {
	Type     string `json:"type,omitempty" yaml:"type,omitempty"`
	Title    string `json:"title,omitempty" yaml:"title,omitempty"`
	Status   int64  `json:"status,omitempty" yaml:"status,omitempty"`
	Detail   string `json:"detail,omitempty" yaml:"detail,omitempty"`
	Instance string `json:"instance,omitempty" yaml:"instance,omitempty"`
}

https://www.baeldung.com/rest-api-error-handling-best-practices

type MemoryCache

type MemoryCache struct {
	// contains filtered or unexported fields
}

MemoryCache is an implemtation of Cache that stores responses in an in-memory map.

func NewMemoryCache

func NewMemoryCache() *MemoryCache

NewMemoryCache returns a new Cache that will store items in an in-memory map

func (*MemoryCache) Delete

func (c *MemoryCache) Delete(key string)

Delete removes key from the cache

func (*MemoryCache) Get

func (c *MemoryCache) Get(key string) (resp []byte, ok bool)

Get returns the []byte representation of the response and true if present, false if not

func (*MemoryCache) Set

func (c *MemoryCache) Set(key string, resp []byte)

Set saves response resp to the cache with key

type Transport

type Transport struct {
	// The RoundTripper interface actually used to make requests
	// If nil, http.DefaultTransport is used
	Transport http.RoundTripper
	Cache     Cache
	// If true, responses returned from the cache will be given an extra header, X-From-Cache
	MarkCachedResponses bool
	// If true, caching will be controlled locally
	UseLocalCacheTimes bool
}

Transport is an implementation of http.RoundTripper that will return values from a cache where possible (avoiding a network request) and will additionally add validators (etag/if-modified-since) to repeated requests allowing servers to return 304 / Not Modified

func NewMemoryCacheTransport

func NewMemoryCacheTransport() *Transport

NewMemoryCacheTransport returns a new Transport using the in-memory cache implementation

func NewTransport

func NewTransport(c Cache) *Transport

NewTransport returns a new Transport with the provided Cache implementation and MarkCachedResponses set to true

func NewTransportLocalCacheTime

func NewTransportLocalCacheTime(c Cache) *Transport

NewTransport returns a new Transport with the provided Cache implementation and MarkCachedResponses and UseLocalCacheTimes set to true

func (*Transport) Client

func (t *Transport) Client() *http.Client

Client returns an *http.Client that caches responses.

func (*Transport) RoundTrip

func (t *Transport) RoundTrip(req *http.Request) (resp *http.Response, err error)

RoundTrip takes a Request and returns a Response

If there is a fresh Response already in cache, then it will be returned without connecting to the server.

If there is a stale Response, then any validators it contains will be set on the new request to give the server a chance to respond with NotModified. If this happens, then the cached Response will be returned.

type WebhookConfig

type WebhookConfig struct {
	Log               *zap.Logger
	MaxRetries        int
	Url               string
	Body              string
	HookSecret        string
	SignatureHeader   string
	AdditionalHeaders map[string]string
	BearerToken       string
}

func (*WebhookConfig) SendWebhook

func (c *WebhookConfig) SendWebhook() error