request_tracers

Documentation

Index

• type Error
• type RequestTracerService
  • func NewRequestTracerService(opts ...option.RequestOption) (r *RequestTracerService)
• type RequestTracerTrace
• type TraceNewParams
  • func (r TraceNewParams) MarshalJSON() (data []byte, err error)
• type TraceNewParamsBody
  • func (r TraceNewParamsBody) MarshalJSON() (data []byte, err error)
• type TraceNewParamsContext
  • func (r TraceNewParamsContext) MarshalJSON() (data []byte, err error)
• type TraceNewParamsContextGeoloc
  • func (r TraceNewParamsContextGeoloc) MarshalJSON() (data []byte, err error)
• type TraceNewResponse
  • func (r *TraceNewResponse) UnmarshalJSON(data []byte) (err error)
• type TraceNewResponseEnvelope
  • func (r *TraceNewResponseEnvelope) UnmarshalJSON(data []byte) (err error)
• type TraceNewResponseEnvelopeErrors
  • func (r *TraceNewResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)
• type TraceNewResponseEnvelopeMessages
  • func (r *TraceNewResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)
• type TraceNewResponseEnvelopeSuccess
  • func (r TraceNewResponseEnvelopeSuccess) IsKnown() bool
• type TraceService
  • func NewTraceService(opts ...option.RequestOption) (r *TraceService)
  • func (r *TraceService) New(ctx context.Context, accountIdentifier string, body TraceNewParams, ...) (res *TraceNewResponse, err error)

Types

type Error

type Error = apierror.Error

type RequestTracerService

type RequestTracerService struct {
	Options []option.RequestOption
	Traces  *TraceService
}

RequestTracerService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewRequestTracerService method instead.

func NewRequestTracerService

func NewRequestTracerService(opts ...option.RequestOption) (r *RequestTracerService)

NewRequestTracerService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

type RequestTracerTrace

type RequestTracerTrace []RequestTracerTrace

type TraceNewParams

type TraceNewParams struct {
	// HTTP Method of tracing request
	Method param.Field[string] `json:"method,required"`
	// URL to which perform tracing request
	URL  param.Field[string]             `json:"url,required"`
	Body param.Field[TraceNewParamsBody] `json:"body"`
	// Additional request parameters
	Context param.Field[TraceNewParamsContext] `json:"context"`
	// Cookies added to tracing request
	Cookies param.Field[map[string]string] `json:"cookies"`
	// Headers added to tracing request
	Headers param.Field[map[string]string] `json:"headers"`
	// HTTP Protocol of tracing request
	Protocol param.Field[string] `json:"protocol"`
	// Skip sending the request to the Origin server after all rules evaluation
	SkipResponse param.Field[bool] `json:"skip_response"`
}

func (TraceNewParams) MarshalJSON

func (r TraceNewParams) MarshalJSON() (data []byte, err error)

type TraceNewParamsBody

type TraceNewParamsBody struct {
	// Base64 encoded request body
	Base64 param.Field[string] `json:"base64"`
	// Arbitrary json as request body
	Json param.Field[interface{}] `json:"json"`
	// Request body as plain text
	PlainText param.Field[string] `json:"plain_text"`
}

func (TraceNewParamsBody) MarshalJSON

func (r TraceNewParamsBody) MarshalJSON() (data []byte, err error)

type TraceNewParamsContext

type TraceNewParamsContext struct {
	// Bot score used for evaluating tracing request processing
	BotScore param.Field[int64] `json:"bot_score"`
	// Geodata for tracing request
	Geoloc param.Field[TraceNewParamsContextGeoloc] `json:"geoloc"`
	// Whether to skip any challenges for tracing request (e.g.: captcha)
	SkipChallenge param.Field[bool] `json:"skip_challenge"`
	// Threat score used for evaluating tracing request processing
	ThreatScore param.Field[int64] `json:"threat_score"`
}

Additional request parameters

func (TraceNewParamsContext) MarshalJSON

func (r TraceNewParamsContext) MarshalJSON() (data []byte, err error)

type TraceNewParamsContextGeoloc

type TraceNewParamsContextGeoloc struct {
	City                param.Field[string]  `json:"city"`
	Continent           param.Field[string]  `json:"continent"`
	IsEuCountry         param.Field[bool]    `json:"is_eu_country"`
	ISOCode             param.Field[string]  `json:"iso_code"`
	Latitude            param.Field[float64] `json:"latitude"`
	Longitude           param.Field[float64] `json:"longitude"`
	PostalCode          param.Field[string]  `json:"postal_code"`
	RegionCode          param.Field[string]  `json:"region_code"`
	Subdivision2ISOCode param.Field[string]  `json:"subdivision_2_iso_code"`
	Timezone            param.Field[string]  `json:"timezone"`
}

Geodata for tracing request

func (TraceNewParamsContextGeoloc) MarshalJSON

func (r TraceNewParamsContextGeoloc) MarshalJSON() (data []byte, err error)

type TraceNewResponse

type TraceNewResponse struct {
	// HTTP Status code of zone response
	StatusCode int64                `json:"status_code"`
	Trace      RequestTracerTrace   `json:"trace"`
	JSON       traceNewResponseJSON `json:"-"`
}

Trace result with an origin status code

func (*TraceNewResponse) UnmarshalJSON

func (r *TraceNewResponse) UnmarshalJSON(data []byte) (err error)

type TraceNewResponseEnvelope

type TraceNewResponseEnvelope struct {
	Errors   []TraceNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []TraceNewResponseEnvelopeMessages `json:"messages,required"`
	// Trace result with an origin status code
	Result TraceNewResponse `json:"result,required"`
	// Whether the API call was successful
	Success TraceNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    traceNewResponseEnvelopeJSON    `json:"-"`
}

func (*TraceNewResponseEnvelope) UnmarshalJSON

func (r *TraceNewResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type TraceNewResponseEnvelopeErrors

type TraceNewResponseEnvelopeErrors struct {
	Code    int64                              `json:"code,required"`
	Message string                             `json:"message,required"`
	JSON    traceNewResponseEnvelopeErrorsJSON `json:"-"`
}

func (*TraceNewResponseEnvelopeErrors) UnmarshalJSON

func (r *TraceNewResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type TraceNewResponseEnvelopeMessages

type TraceNewResponseEnvelopeMessages struct {
	Code    int64                                `json:"code,required"`
	Message string                               `json:"message,required"`
	JSON    traceNewResponseEnvelopeMessagesJSON `json:"-"`
}

func (*TraceNewResponseEnvelopeMessages) UnmarshalJSON

func (r *TraceNewResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type TraceNewResponseEnvelopeSuccess

type TraceNewResponseEnvelopeSuccess bool

Whether the API call was successful

const (
	TraceNewResponseEnvelopeSuccessTrue TraceNewResponseEnvelopeSuccess = true
)

func (TraceNewResponseEnvelopeSuccess) IsKnown

func (r TraceNewResponseEnvelopeSuccess) IsKnown() bool

type TraceService

type TraceService struct {
	Options []option.RequestOption
}

TraceService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewTraceService method instead.

func NewTraceService

func NewTraceService(opts ...option.RequestOption) (r *TraceService)

NewTraceService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*TraceService) New

func (r *TraceService) New(ctx context.Context, accountIdentifier string, body TraceNewParams, opts ...option.RequestOption) (res *TraceNewResponse, err error)

Request Trace