Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func MakeBatchRequests

func MakeBatchRequests(
	ctx context.Context,
	requests []BatchParsedHTTPRequest,
	reqCount, globalLimit, perHostLimit int,
) <-chan error

    MakeBatchRequests concurrently makes multiple requests. It spawns min(reqCount, globalLimit) goroutines that asynchronously process all requests coming from the requests channel. Responses are recorded in the pointers contained in each BatchParsedHTTPRequest object, so they need to be pre-initialized. In addition, each processed request would emit either a nil value, or an error, via the returned errors channel. The goroutines exit when the requests channel is closed.

    func SetRequestCookies

    func SetRequestCookies(req *http.Request, jar *cookiejar.Jar, reqCookies map[string]*HTTPRequestCookie)

      SetRequestCookies sets the cookies of the requests getting those cookies both from the jar and from the reqCookies map. The Replace field of the HTTPRequestCookie will be taken into account

      Types

      type BatchParsedHTTPRequest

      type BatchParsedHTTPRequest struct {
      	*ParsedHTTPRequest
      	Response *Response // this is modified by MakeBatchRequests()
      }

        BatchParsedHTTPRequest extends the normal parsed HTTP request with a pointer to a Response object, so that the batch goroutines can concurrently store the responses they receive, without any locking.

        type CompressionType

        type CompressionType uint

          CompressionType is used to specify what compression is to be used to compress the body of a request The conversion and validation methods are auto-generated with https://github.com/alvaroloes/enumer: nolint: lll go:generate enumer -type=CompressionType -transform=snake -trimprefix CompressionType -output compression_type_gen.go

          const (
          	// CompressionTypeGzip compresses through gzip
          	CompressionTypeGzip CompressionType = iota
          	// CompressionTypeDeflate compresses through flate
          	CompressionTypeDeflate
          	// CompressionTypeZstd compresses through zstd
          	CompressionTypeZstd
          	// CompressionTypeBr compresses through brotli
          	CompressionTypeBr
          )

          func CompressionTypeString

          func CompressionTypeString(s string) (CompressionType, error)

            CompressionTypeString retrieves an enum value from the enum constants string name. Throws an error if the param is not part of the enum.

            func CompressionTypeValues

            func CompressionTypeValues() []CompressionType

              CompressionTypeValues returns all values of the enum

              func (CompressionType) IsACompressionType

              func (i CompressionType) IsACompressionType() bool

                IsACompressionType returns "true" if the value is listed in the enum definition. "false" otherwise

                func (CompressionType) String

                func (i CompressionType) String() string

                type HTTPCookie

                type HTTPCookie struct {
                	Name, Value, Domain, Path string
                	HTTPOnly, Secure          bool
                	MaxAge                    int
                	Expires                   int64
                }

                  HTTPCookie is a representation of an http cookies used in the Response object

                  type HTTPRequestCookie

                  type HTTPRequestCookie struct {
                  	Name, Value string
                  	Replace     bool
                  }

                    HTTPRequestCookie is a representation of a cookie used for request objects

                    type K6Error

                    type K6Error struct {
                    	Code          errCode
                    	Message       string
                    	OriginalError error
                    }

                      K6Error is a helper struct that enhances Go errors with custom k6-specific error-codes and more user-readable error messages.

                      func NewK6Error

                      func NewK6Error(code errCode, msg string, originalErr error) K6Error

                        NewK6Error is the constructor for K6Error

                        func (K6Error) Error

                        func (k6Err K6Error) Error() string

                          Error implements the `error` interface, so K6Errors are normal Go errors.

                          func (K6Error) Unwrap

                          func (k6Err K6Error) Unwrap() error

                            Unwrap implements the `xerrors.Wrapper` interface, so K6Errors are a bit future-proof Go 2 errors.

                            type ParsedHTTPRequest

                            type ParsedHTTPRequest struct {
                            	URL          *URL
                            	Body         *bytes.Buffer
                            	Req          *http.Request
                            	Timeout      time.Duration
                            	Auth         string
                            	Throw        bool
                            	ResponseType ResponseType
                            	Compressions []CompressionType
                            	Redirects    null.Int
                            	ActiveJar    *cookiejar.Jar
                            	Cookies      map[string]*HTTPRequestCookie
                            	Tags         map[string]string
                            }

                              ParsedHTTPRequest a represantion of a request after it has been parsed from a user script

                              type Request

                              type Request struct {
                              	Method  string                          `json:"method"`
                              	URL     string                          `json:"url"`
                              	Headers map[string][]string             `json:"headers"`
                              	Body    string                          `json:"body"`
                              	Cookies map[string][]*HTTPRequestCookie `json:"cookies"`
                              }

                                Request represent an http request

                                type Response

                                type Response struct {
                                	RemoteIP       string                   `json:"remote_ip"`
                                	RemotePort     int                      `json:"remote_port"`
                                	URL            string                   `json:"url"`
                                	Status         int                      `json:"status"`
                                	StatusText     string                   `json:"status_text"`
                                	Proto          string                   `json:"proto"`
                                	Headers        map[string]string        `json:"headers"`
                                	Cookies        map[string][]*HTTPCookie `json:"cookies"`
                                	Body           interface{}              `json:"body"`
                                	Timings        ResponseTimings          `json:"timings"`
                                	TLSVersion     string                   `json:"tls_version"`
                                	TLSCipherSuite string                   `json:"tls_cipher_suite"`
                                	OCSP           netext.OCSP              `json:"ocsp"`
                                	Error          string                   `json:"error"`
                                	ErrorCode      int                      `json:"error_code"`
                                	Request        Request                  `json:"request"`
                                	// contains filtered or unexported fields
                                }

                                  Response is a representation of an HTTP response

                                  func MakeRequest

                                  func MakeRequest(ctx context.Context, preq *ParsedHTTPRequest) (*Response, error)

                                    MakeRequest makes http request for tor the provided ParsedHTTPRequest

                                    func (*Response) GetCtx

                                    func (res *Response) GetCtx() context.Context

                                      GetCtx return the response context

                                      func (*Response) JSON

                                      func (res *Response) JSON(selector ...string) (interface{}, error)

                                        JSON parses the body of a response as json and returns it to the goja VM

                                        type ResponseTimings

                                        type ResponseTimings struct {
                                        	Duration       float64 `json:"duration"`
                                        	Blocked        float64 `json:"blocked"`
                                        	LookingUp      float64 `json:"looking_up"`
                                        	Connecting     float64 `json:"connecting"`
                                        	TLSHandshaking float64 `json:"tls_handshaking"`
                                        	Sending        float64 `json:"sending"`
                                        	Waiting        float64 `json:"waiting"`
                                        	Receiving      float64 `json:"receiving"`
                                        }

                                          ResponseTimings is a struct to put all timings for a given HTTP response/request

                                          type ResponseType

                                          type ResponseType uint

                                            ResponseType is used in the request to specify how the response body should be treated The conversion and validation methods are auto-generated with https://github.com/alvaroloes/enumer: nolint: lll go:generate enumer -type=ResponseType -transform=snake -json -text -trimprefix ResponseType -output response_type_gen.go

                                            const (
                                            	// ResponseTypeText causes k6 to return the response body as a string. It works
                                            	// well for web pages and JSON documents, but it can cause issues with
                                            	// binary files since their data could be lost when they're converted in the
                                            	// UTF-16 strings JavaScript uses.
                                            	// This is the default value for backwards-compatibility, unless the global
                                            	// discardResponseBodies option is enabled.
                                            	ResponseTypeText ResponseType = iota
                                            	// ResponseTypeBinary causes k6 to return the response body as a []byte, suitable
                                            	// for working with binary files without lost data and needless string conversions.
                                            	ResponseTypeBinary
                                            	// ResponseTypeNone causes k6 to fully read the response body while immediately
                                            	// discarding the actual data - k6 would set the body of the returned HTTPResponse
                                            	// to null. This saves CPU and memory and is suitable for HTTP requests that we just
                                            	// want to  measure, but we don't care about their responses' contents. This is the
                                            	// default value for all requests if the global discardResponseBodies is enablled.
                                            	ResponseTypeNone
                                            )

                                            func ResponseTypeString

                                            func ResponseTypeString(s string) (ResponseType, error)

                                              ResponseTypeString retrieves an enum value from the enum constants string name. Throws an error if the param is not part of the enum.

                                              func ResponseTypeValues

                                              func ResponseTypeValues() []ResponseType

                                                ResponseTypeValues returns all values of the enum

                                                func (ResponseType) IsAResponseType

                                                func (i ResponseType) IsAResponseType() bool

                                                  IsAResponseType returns "true" if the value is listed in the enum definition. "false" otherwise

                                                  func (ResponseType) MarshalJSON

                                                  func (i ResponseType) MarshalJSON() ([]byte, error)

                                                    MarshalJSON implements the json.Marshaler interface for ResponseType

                                                    func (ResponseType) MarshalText

                                                    func (i ResponseType) MarshalText() ([]byte, error)

                                                      MarshalText implements the encoding.TextMarshaler interface for ResponseType

                                                      func (ResponseType) String

                                                      func (i ResponseType) String() string

                                                      func (*ResponseType) UnmarshalJSON

                                                      func (i *ResponseType) UnmarshalJSON(data []byte) error

                                                        UnmarshalJSON implements the json.Unmarshaler interface for ResponseType

                                                        func (*ResponseType) UnmarshalText

                                                        func (i *ResponseType) UnmarshalText(text []byte) error

                                                          UnmarshalText implements the encoding.TextUnmarshaler interface for ResponseType

                                                          type Tracer

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

                                                            A Tracer wraps "net/http/httptrace" to collect granular timings for HTTP requests. Note that since there is not yet an event for the end of a request (there's a PR to add it), you must call Done() at the end of the request to get the full timings. It's NOT safe to reuse Tracers between requests. Cheers, love, the cavalry's here.

                                                            func (*Tracer) ConnectDone

                                                            func (t *Tracer) ConnectDone(network, addr string, err error)

                                                              ConnectDone is called when a new connection's Dial completes. The provided err indicates whether the connection completedly successfully. If net.Dialer.DualStack ("Happy Eyeballs") support is enabled, this may be called multiple times.

                                                              If the connection is reused, this won't be called. Otherwise, it will be called after ConnectStart() and before either TLSHandshakeStart() (for TLS connections) or GotConn().

                                                              func (*Tracer) ConnectStart

                                                              func (t *Tracer) ConnectStart(network, addr string)

                                                                ConnectStart is called when a new connection's Dial begins. If net.Dialer.DualStack (IPv6 "Happy Eyeballs") support is enabled, this may be called multiple times.

                                                                If the connection is reused, this won't be called. Otherwise, it will be called after GetConn() and before ConnectDone().

                                                                func (*Tracer) Done

                                                                func (t *Tracer) Done() *Trail

                                                                  Done calculates all metrics and should be called when the request is finished.

                                                                  func (*Tracer) GetConn

                                                                  func (t *Tracer) GetConn(hostPort string)

                                                                    GetConn is called before a connection is created or retrieved from an idle pool. The hostPort is the "host:port" of the target or proxy. GetConn is called even if there's already an idle cached connection available.

                                                                    Keep in mind that GetConn won't be called if a connection is reused though, for example when there's a redirect. If it's called, it will be called before all other hooks.

                                                                    func (*Tracer) GotConn

                                                                    func (t *Tracer) GotConn(info httptrace.GotConnInfo)

                                                                      GotConn is called after a successful connection is obtained. There is no hook for failure to obtain a connection; instead, use the error from Transport.RoundTrip.

                                                                      This is the fist hook called for reused connections. For new connections, it's called either after TLSHandshakeDone() (for TLS connections) or after ConnectDone()

                                                                      func (*Tracer) GotFirstResponseByte

                                                                      func (t *Tracer) GotFirstResponseByte()

                                                                        GotFirstResponseByte is called when the first byte of the response headers is available. If the request was cancelled, this could be called after the RoundTrip() method has returned.

                                                                        func (*Tracer) TLSHandshakeDone

                                                                        func (t *Tracer) TLSHandshakeDone(state tls.ConnectionState, err error)

                                                                          TLSHandshakeDone is called after the TLS handshake with either the successful handshake's connection state, or a non-nil error on handshake failure.

                                                                          If the connection is reused, this won't be called. Otherwise, it will be called after TLSHandshakeStart() and before GotConn(). If the request was cancelled, this could be called after the RoundTrip() method has returned.

                                                                          func (*Tracer) TLSHandshakeStart

                                                                          func (t *Tracer) TLSHandshakeStart()

                                                                            TLSHandshakeStart is called when the TLS handshake is started. When connecting to a HTTPS site via a HTTP proxy, the handshake happens after the CONNECT request is processed by the proxy.

                                                                            If the connection is reused, this won't be called. Otherwise, it will be called after ConnectDone() and before TLSHandshakeDone().

                                                                            func (*Tracer) Trace

                                                                            func (t *Tracer) Trace() *httptrace.ClientTrace

                                                                              Trace returns a premade ClientTrace that calls all of the Tracer's hooks.

                                                                              func (*Tracer) WroteRequest

                                                                              func (t *Tracer) WroteRequest(info httptrace.WroteRequestInfo)

                                                                                WroteRequest is called with the result of writing the request and any body. It may be called multiple times in the case of retried requests.

                                                                                type Trail

                                                                                type Trail struct {
                                                                                	EndTime time.Time
                                                                                
                                                                                	// Total connect time (Connecting + TLSHandshaking)
                                                                                	ConnDuration time.Duration
                                                                                
                                                                                	// Total request duration, excluding DNS lookup and connect time.
                                                                                	Duration time.Duration
                                                                                
                                                                                	Blocked        time.Duration // Waiting to acquire a connection.
                                                                                	Connecting     time.Duration // Connecting to remote host.
                                                                                	TLSHandshaking time.Duration // Executing TLS handshake.
                                                                                	Sending        time.Duration // Writing request.
                                                                                	Waiting        time.Duration // Waiting for first byte.
                                                                                	Receiving      time.Duration // Receiving response.
                                                                                
                                                                                	// Detailed connection information.
                                                                                	ConnReused     bool
                                                                                	ConnRemoteAddr net.Addr
                                                                                
                                                                                	// Populated by SaveSamples()
                                                                                	Tags    *stats.SampleTags
                                                                                	Samples []stats.Sample
                                                                                }

                                                                                  A Trail represents detailed information about an HTTP request. You'd typically get one from a Tracer.

                                                                                  func (*Trail) GetSamples

                                                                                  func (tr *Trail) GetSamples() []stats.Sample

                                                                                    GetSamples implements the stats.SampleContainer interface.

                                                                                    func (*Trail) GetTags

                                                                                    func (tr *Trail) GetTags() *stats.SampleTags

                                                                                      GetTags implements the stats.ConnectedSampleContainer interface.

                                                                                      func (*Trail) GetTime

                                                                                      func (tr *Trail) GetTime() time.Time

                                                                                        GetTime implements the stats.ConnectedSampleContainer interface.

                                                                                        func (*Trail) SaveSamples

                                                                                        func (tr *Trail) SaveSamples(tags *stats.SampleTags)

                                                                                          SaveSamples populates the Trail's sample slice so they're accesible via GetSamples()

                                                                                          type URL

                                                                                          type URL struct {
                                                                                          	Name     string // http://example.com/thing/${}/
                                                                                          	URL      string // http://example.com/thing/1234/
                                                                                          	CleanURL string // URL with masked user credentials, used for output
                                                                                          	// contains filtered or unexported fields
                                                                                          }

                                                                                            A URL wraps net.URL, and preserves the template (if any) the URL was constructed from.

                                                                                            func NewURL

                                                                                            func NewURL(urlString, name string) (URL, error)

                                                                                              NewURL returns a new URL for the provided url and name. The error is returned if the url provided can't be parsed

                                                                                              func (URL) Clean

                                                                                              func (u URL) Clean() string

                                                                                                Clean returns an output-safe representation of URL

                                                                                                func (URL) GetURL

                                                                                                func (u URL) GetURL() *url.URL

                                                                                                  GetURL returns the internal url.URL