tests

package
v0.0.0-...-644905b Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 29, 2022 License: MIT Imports: 16 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ProjectConfigRequest     requestType = 0
	InvalidateProjectRequest requestType = 1
)

Variables

This section is empty.

Functions

func AppContextGenerator 

func AppContextGenerator() func() AppContext
func BreadcrumbsGenerator(min uint64, max uint64, categories []string, levels []string, types []string, messages []string) func() []Breadcrumb

func DeviceContextGenerator 

func DeviceContextGenerator() func() DeviceContext

func EventIdGenerator 

func EventIdGenerator() func() string

func Flip 

func Flip() bool

Flip returns a randomly generated bool (flips a coin)

func FromUTCString 

func FromUTCString(date string) (time.Time, error)

func MeasurementsGenerator 

func MeasurementsGenerator(measurements []string) func() map[string]float64

func NewVirtualRelay 

func NewVirtualRelay() *virtualRelay

func OperationGenerator 

func OperationGenerator(operations []string) func() string

func OsContextGenerator 

func OsContextGenerator() func() OsContext

func RegisterTestType 

func RegisterTestType(name string, tester LoadTesterBuilder, splitter LoadSplitter)

RegisterTestType registers the necessary test handlers (LoadTesterBuilder and LoadSplitter) with a test type (a string). This enables the service loop to retrieve the proper handlers for a test request. The service loop looks-up the proper handlers by using the request TestParams.Name field and then starts the attack with the retrieved handlers.

func ReleaseGenerator 

func ReleaseGenerator(numReleases uint64) func() string

func SpanIdGenerator 

func SpanIdGenerator() func() string

func SpanStatusGenerator 

func SpanStatusGenerator() func() string

func SpansGenerator 

func SpansGenerator(minSpans uint64, maxSpans uint64, operations []string) func(transactionId string, traceId string, transactionStart time.Time, timestamp time.Time) []Span

func TraceContextGenerator 

func TraceContextGenerator(operations []string) func() TraceContext

func TransactionGenerator 

func TransactionGenerator(job TransactionJobCommon) func(time.Duration) Transaction

func UserGenerator 

func UserGenerator(maxUsers uint64) func() User

func VersionGenerator 

func VersionGenerator(numSegments uint64, maxValue uint64) func() string

Types

type AppContext 

type AppContext struct {
	AppStartTime  string `json:"app_start_time,omitempty"`
	DeviceAppHash string `json:"device_app_hash,omitempty"`
	BuildType     string `json:"build_type,omitempty"`
	AppIdentifier string `json:"app_identifier,omitempty"`
	AppName       string `json:"app_name,omitempty"`
	AppVersion    string `json:"app_version,omitempty"`
	AppBuild      string `json:"app_build,omitempty"`
	Type          string `json:"type,omitempty"`
}
type Breadcrumb struct {
	Timestamp float64 `json:"timestamp"`
	Ty        string  `json:"ty"`
	Category  string  `json:"category"`
	Level     string  `json:"level"`
	Message   string  `json:"message"`
	Data      any     `json:"data"`
	EventId   string  `json:"event_id"`
}

type BucketType 

type BucketType string
const (
	Distribution BucketType = "d"
	Counter      BucketType = "c"
	Set          BucketType = "s"
	Gauge        BucketType = "g"
)

type Contexts 

type Contexts struct {
	Os     OsContext     `json:"os,omitempty"`
	Device DeviceContext `json:"device,omitempty"`
	App    AppContext    `json:"app,omitempty"`
	Trace  TraceContext  `json:"trace,omitempty"`
}

type DeviceContext 

type DeviceContext struct {
	Name                string  `json:"name,omitempty"`
	Family              string  `json:"family,omitempty"`
	Model               string  `json:"model,omitempty"`
	ModelId             string  `json:"model_id,omitempty"`
	Arch                string  `json:"arch,omitempty"`
	BatteryLevel        float64 `json:"battery_level,omitempty"`
	Orientation         string  `json:"orientation,omitempty"`
	Manufacturer        string  `json:"manufacturer,omitempty"`
	Brand               string  `json:"brand,omitempty"`
	ScreenResolution    string  `json:"screen_resolution,omitempty"`
	ScreenDensity       uint64  `json:"screen_density,omitempty"`
	ScreenDpi           uint64  `json:"screen_dpi,omitempty"`
	Online              bool    `json:"online,omitempty"`
	Charging            bool    `json:"charging,omitempty"`
	LowMemory           bool    `json:"low_memory,omitempty"`
	Simulator           bool    `json:"simulator,omitempty"`
	MemorySize          uint64  `json:"memory_size,omitempty"`
	FreeMemory          uint64  `json:"free_memory,omitempty"`
	UsableMemory        uint64  `json:"usable_memory,omitempty"`
	StorageSize         uint64  `json:"storage_size,omitempty"`
	FreeStorage         uint64  `json:"free_storage,omitempty"`
	ExternalStorageSize uint64  `json:"external_storage_size,omitempty"`
	ExternalFreeStorage uint64  `json:"external_free_storage,omitempty"`
	BootTime            string  `json:"boot_time,omitempty"`
	Timezone            string  `json:"timezone,omitempty"`
	Type                string  `json:"type,omitempty"`
}

type GaugeValue 

type GaugeValue struct {
	Max   float64 `json:"max"`
	Min   float64 `json:"min"`
	Sum   float64 `json:"sum"`
	Last  float64 `json:"last"`
	Count uint64  `json:"count"`
}

type LoadSplitter 

type LoadSplitter func(masterParams TestParams, numWorkers int) ([]TestParams, error)

LoadSplitter is a function that knows how to split a load test request between multiple workers. In the simplest (and most common) case it just splits the load messages/timeInterval to the number of workers by giving each worker the load messages/(timeInterval * numWorkers). If this is your case just use SimpleLoadSplitter, if you need something more sophisticated implement your own that decomposes your TestParams in the proper way required by your test. Note: The function must return a slice of TestParams of size numWorkers.

func GetLoadSplitter 

func GetLoadSplitter(testType string) LoadSplitter

GetLoadSplitter a loadSplitter for the current type of test.

type LoadTester 

type LoadTester interface {
	// GetTargeter will be called by the worker at the beginning of an attack in order to
	// create a targeter for the particular TestParams passed. This Targeter will be used
	// during the attack to construct requests (this function will be called once per attack)
	GetTargeter() (vegeta.Targeter, uint64)
	// ProcessResult will be called by the worker during an attack for each Result returned by the system
	// under test. If you don't care about the results returned just provide an empty implementation.
	ProcessResult(res *vegeta.Result, seq uint64)
}

LoadTester is an interface implemented by all load tests. This is used by the web_server.worker to handle loads based on the TestParams passed in the request.

type LoadTesterBuilder 

type LoadTesterBuilder func(targetUrl string, params json.RawMessage) LoadTester

LoadTesterBuilder is a function that when given a target URL and a read channel of raw JSON messages returns a LoadTester that is able to change the events it generates to reflect the parameter passed through the JSON messages channel. The target url is generally the base url of the server under test. The LoadTester return must be able to create a vegeta.Targeter, that is an object that returns load test requests and therefore must be able to create the urls of the load test requests, the targetUrl is used for this. The target url is coming (in the current implementation) from a CLI parameter. Note: the raw JSON messages received through the channel need to be "compatible" with the specific targeter. Getting the proper builder for a type of message is outside this function's responsibilities (the dispatch is done via GetLoadTester inside the worker)

func GetLoadTester 

func GetLoadTester(testType string) LoadTesterBuilder

GetLoadTester returns the TargeterBuilder for a particular type of message.

type MetricBucket 

type MetricBucket struct {
	Name  string `json:"name"`
	Unit  string `json:"unit"`
	Width uint64 `json:"width"`
	// one of
	Type BucketType `json:"type"`
	// Value is []float64 for distribution, float64 for counter, []int32 for set, GaugeValue for gauge
	Value     any               `json:"value"`
	Timestamp int64             `json:"timestamp"`
	Tags      map[string]string `json:"tags"`
}

type MetricBucketJob 

type MetricBucketJob struct {
	// NumMetricNames represents the total number of metric names that will be generated
	NumMetricNames int `json:"numMetricNames"`
	// NumProjects represents the number of projects that will be used for the metric messages
	NumProjects int `json:"numProjects"`
	// NumDistributions created in each messages
	NumDistributions int `json:"numDistributions"`
	// NumberGauges created in each message
	NumGauges int `json:"numGauges"`
	// NumSets created in each messages
	NumSets int `json:"numSets"`
	// NumCounters created in each message
	NumCounters int `json:"numCounters"`
	// MinMetricsInDistribution the minimum number of metrics created in each distribution bucket
	MinMetricsInDistribution int `json:"minMetricsInDistribution"`
	// MaxMetricsInDistribution the maximum number of metrics created in each distribution bucket
	MaxMetricsInDistribution int `json:"maxMetricsInDistribution"`
	// MinMetricsInSets the minimum number of metrics created in each set
	MinMetricsInSets int `json:"minMetricsInSets"`
	// MaxMetricsInSets the maximum number of metrics created in each set
	MaxMetricsInSets int `json:"maxMetricsInSets"`
	// NumTagsPerMetric Number of tags created for each bucket
	// To make things predictable each bucket will contain the all the tags
	// The number of total buckets can be calculated as NumTagsPerMetric^NumValuesPerTag
	NumTagsPerMetric int `json:"numTagsPerMetric"`
	// NumValuesPerTag how many distinct values are generated for each tag
	NumValuesPerTag int `json:"numValuesPerTag"`
}

MetricBucketJob is how a metricBucket job is parametrized example: ```json 

{
  "numMetricNames": 100,
  "numProjects": 1000,
  "numDistributions": 7,
  "numGauges": 0,
  "numSets": 3,
  "numCounters": 8,
  "minMetricsInDistribution": 4,
  "maxMetricsInDistribution": 25,
  "minMetricsInSets": 4,
  "maxMetricsInSets": 30,
  "numTagsPerMetric": 5,
  "numValuesPerTag": 3
}

```

type OsContext 

type OsContext struct {
	Type          string `json:"type,omitempty"`
	Rooted        *bool  `json:"rooted,omitempty"`
	KernelVersion string `json:"kernel_version,omitempty"`
	Version       string `json:"version,omitempty"`
	Built         string `json:"built,omitempty"`
	Name          string `json:"name,omitempty"`
}

type ProjectConfigJob 

type ProjectConfigJob struct {
	// NumRelays is the number of relays to use
	NumRelays int
	// NumProjects to use in the requests
	NumProjects int
	// MinBatchSize the minimum number of project in a project config request
	MinBatchSize int
	// MaxBatchSize the maximum number of projects in a project config request
	MaxBatchSize int
	// BatchInterval is the duration of validity of a project config
	BatchInterval time.Duration
	// The ratio from the number of requests that are invalidation requests (should be between 0 and 1).
	ProjectInvalidationRatio float64
	// RelayPublicKey public key for Relay authentication
	RelayPublicKey string
	// RelayPrivateKey private key for Relay authentication
	RelayPrivateKey string
	// RelayId is the id of the Relay used for authentication
	RelayId string
}

ProjectConfigJob is how a projectConfigJob is parametrized

Here's an example of project config parameters: ```json 

{
  "numRelays": 50,
  "numProjects": 10000,
  "minBatchSize": 10,
  "maxBatchSize": 100,
  "BatchInterval": "5s",
  "projectInvalidationRatio": 0.001,
  "RelayPublicKey": "ftFuDNBFm8-kPpuCuaWMio_mJAW2txCFCsaLMHn2vv0",
  "RelayPrivateKey": "uZUtRaayN8uuuTTOjbs5EDfqWNwyDfFro6TERx6Wfhs",
  "RelayId": "aaa12340-a123-123b-4567-0afe1f27e066"
}

```

func (ProjectConfigJob) MarshalJSON 

func (pcj ProjectConfigJob) MarshalJSON() ([]byte, error)

func (ProjectConfigJob) MarshalYaml 

func (pcj ProjectConfigJob) MarshalYaml() ([]byte, error)

func (*ProjectConfigJob) UnmarshalJSON 

func (pcj *ProjectConfigJob) UnmarshalJSON(b []byte) error

func (*ProjectConfigJob) UnmarshalYaml 

func (pcj *ProjectConfigJob) UnmarshalYaml(b []byte) error

type ProjectProfile 

type ProjectProfile struct {
	// NumProjects number of projects that use this profile
	NumProjects int `json:"numProjects" yaml:"numProjects"`
	// Relative frequency of project from this profile in relation with projects from other profiles
	RelativeFreqWeight float64 `json:"relativeFreqWeight" yaml:"relativeFreqWeight"`
	// The timestamp histogram for projects in this profile
	TimestampHistogram []TimestampHistogramBucket `json:"timestampHistogram" yaml:"TimestampHistogram"`
}

ProjectProfile represents a group of projects with the same relative frequency and the same timestamp histogram A request will get an array of ProjectProfile, the example below further explains how this works: Consider the following example in JSON format (the timestamp histogram was removed since it is not relevant in the current explanation). ```json [ 

{ "numProjects": 2, "relativeFreqWeight": 4},
{ "numProjects": 3, "relativeFreqWeight": 2},
{ "numProjects": 4, "relativeFreqWeight": 1}

] ```

In the example above we have 3 groups, the total number of projects generated is 10+1+5 = 16 Events for a particular project in the first bucket will occur twice as often as events for a particular event in the second bucket and four times as frequent as events for a particular project in the second bucket. In other words considering that projects 1,2 belong to bucket 1, projects 3,4,5 to bucket 2 and projects 6,7,8,9 to bucket 3 here's a perfect distribution of events for the profile above 1 1 1 1 2 2 2 2 3 3 4 4 5 5 6 7 8 9 @doc({"scope":"job"})

func (ProjectProfile) GetNumProjects 

func (pp ProjectProfile) GetNumProjects() int

func (ProjectProfile) GetRelativeFreqWeight 

func (pp ProjectProfile) GetRelativeFreqWeight() float64

type Session 

type Session struct {
	Init       bool    `json:"init"`
	Started    string  `json:"started"` // a date time
	Status     string  `json:"status"`  // ok, exited, errored, crashed, abnormal
	Errors     int64   `json:"errors"`
	Duration   float64 `json:"duration"` // duration in seconds
	SessionId  string  `json:"sid"`
	UserId     string  `json:"did,omitempty"`
	Sequence   int64   `json:"seq"`
	Timestamp  string  `json:"timestamp"` // a date time
	Attributes struct {
		Release     string `json:"release"`
		Environment string `json:"environment"`
	} `json:"attrs"`
}

Session serialisation format for sessions

type SessionJob 

type SessionJob struct {
	// NumProjects to use in the requests
	NumProjects int
	// StartedRange represents the duration range for the start of the session relative to now (all generated sessions will have startTime between 0 and -startRange from now)
	StartedRange time.Duration
	// DurationRange the duration of the session ( between 0 and the specified duration)
	DurationRange time.Duration
	// NumReleases represents number of unique releases created
	NumReleases int64
	// NumEnvironments represents the  number of unique environments created
	NumEnvironments int64
	// NumUsers represents the number or unique users created
	NumUsers int64
	// OkWeight represents the relative weight of session with ok status
	OkWeight int64
	// ExitedWeight represents the relative weight of session with exited status
	ExitedWeight int64
	// ExitedWeight represents the relative weight of session with errored status
	ErroredWeight int64
	// CrashedWeight represents the relative weight of session with crashed status
	CrashedWeight int64
	// AbnormalWeight represents the relative weight of session with abnormal status
	AbnormalWeight int64
}

SessionJob is how a session load test is parameterized

Here's an example of session parameters:

```json 

{
  "numProjects": 10000,
  "startedRange": "1m",
  "durationRange": "2m",
  "numReleases": 3,
  "numEnvironments": 4,
  "numUsers": 5,
  "okWeight": 6,
  "exitedWeight": 7,
  "erroredWeight": 8,
  "crashedWeight": 9,
  "abnormalWeight": 10
}

```

func (SessionJob) MarshalJSON 

func (s SessionJob) MarshalJSON() ([]byte, error)

func (SessionJob) MarshalYaml 

func (s SessionJob) MarshalYaml() ([]byte, error)

func (*SessionJob) UnmarshalJSON 

func (s *SessionJob) UnmarshalJSON(b []byte) error

func (*SessionJob) UnmarshalYaml 

func (s *SessionJob) UnmarshalYaml(b []byte) error

type Span 

type Span struct {
	Timestamp      float64           `json:"timestamp,omitempty"`
	StartTimestamp float64           `json:"start_timestamp,omitempty"`
	ExclusiveTime  float64           `json:"exclusive_time,omitempty"`
	Description    string            `json:"description,omitempty"`
	Op             string            `json:"op,omitempty"`
	SpanId         string            `json:"span_id,omitempty"`
	ParentSpanId   string            `json:"parent_span_id,omitempty"`
	TraceId        string            `json:"trace_id,omitempty"`
	Status         string            `json:"status,omitempty"`
	Tags           map[string]string `json:"tags,omitempty"`
	Data           any               `json:"data,omitempty"`
}

func CreateSpan 

func CreateSpan(parentId string, traceId string, timestamp float64, startTimestamp float64, operation string) Span

type TestParams 

type TestParams struct {
	Name           string
	Description    string
	TestType       string
	AttackDuration time.Duration // total time of Attack
	NumMessages    int           // number of messages to be sent in Per
	Per            time.Duration // the unit of duration in which to send NumMessages
	Params         json.RawMessage
	Labels         [][]string // key value pairs (can be used to annotate the attack result)
}

TestParams is Implemented by all parameter test classes

This is how commands are passed in http requests There are 3 main parts to the params:

  1. Details about the attack duration and intensity ( AttackDuration, Per, NumMessages)
  2. Type of the attack, (the Name field) used to dispatch the attack to the appropriate targeter
  3. Parameters specific to the attack (used by the targeter) Params (structure depends on the targeter used) The Description field is optional and used for documenting the attack (e.g. in reporting)

func SimpleLoadSplitter 

func SimpleLoadSplitter(masterParams TestParams, numWorkers int) ([]TestParams, error)

SimpleLoadSplitter implements the typical case of load splitting, where there needs to be no special handling of the load (i.e. each request is independent of each other) and therefore all it does is divide the requested attack frequency to the number of workers so that each worker will handle attack_frequency/numWorkers requests.

func (TestParams) MarshalJSON 

func (t TestParams) MarshalJSON() ([]byte, error)

func (TestParams) MarshalYaml 

func (t TestParams) MarshalYaml() ([]byte, error)

func (*TestParams) UnmarshalJSON 

func (t *TestParams) UnmarshalJSON(b []byte) error

func (*TestParams) UnmarshalYaml 

func (t *TestParams) UnmarshalYaml(b []byte) error

type TimestampHistogramBucket 

type TimestampHistogramBucket struct {
	// Weight is the relative frequency of requests in this bucket, relative to all other buckets
	Weight float64 `json:"weight" yaml:"weight"`
	// MaxDelay The upper bound of the bucket, the lower bound is the previous bucket upper bound or 0 for the first bucket
	MaxDelay utils.StringDuration `json:"maxDelay" yaml:"maxDelay"`
}

TimestampHistogramBucket represents a bucket in a timestamp histogram An array of buckets fully defines a timestamp histogram as in the example below. e.g. consider the following histogram (in json format): ```json [ 

{ "weight": 5, "maxDelay": "1s"},
{ "weight": 3, "maxDelay": "10s"},
{ "weight": 2, "maxDelay": "20s"}

]

``` 

In the example below we have the cumulative weight 5 + 3 + 2 = 10
The request will be generated so that, on average, for every 10 requests
5 will be in the first bucket, 3 in the second and the rest of 2 in the third,
or in other words 50% of the requests will have a timestamp delay of between 0s and 1s,
30% will have a timestamp delay of between 1s and 10s and 20% between 10s and 20s
**Note:** the weight can be any positive numbers (including 0 if you want to skip an interval),
they do not have to add up to 10 (as in the example) or any other number, the
same weight would be achieved by using 0.5,0.3,0.2 or 50,30,20.
@doc({"scope":"job"})

type TraceContext 

type TraceContext struct {
	Type          string  `json:"type,omitempty"`
	TraceId       string  `json:"trace_id,omitempty"`
	SpanId        string  `json:"span_id,omitempty"`
	ParentSpanId  string  `json:"parent_span_id,omitempty"`
	Op            string  `json:"op,omitempty"`
	Status        string  `json:"status,omitempty"`
	ExclusiveTime float64 `json:"exclusive_time,omitempty"`
}

type Transaction 

type Transaction struct {
	Timestamp      string             `json:"timestamp,omitempty"`       // RFC 3339
	StartTimestamp string             `json:"start_timestamp,omitempty"` // RFC 3339
	EventId        string             `json:"event_id"`
	Release        string             `json:"release,omitempty"`
	Transaction    string             `json:"transactionJob,omitempty"`
	Logger         string             `json:"logger,omitempty"`
	Environment    string             `json:"environment,omitempty"`
	User           User               `json:"user,omitempty"`
	Contexts       Contexts           `json:"contexts,omitempty"`
	Breadcrumbs    []Breadcrumb       `json:"breadcrumbs,omitempty"`
	Measurements   map[string]float64 `json:"measurements,omitempty"`
	Spans          []Span             `json:"spans,omitempty"`
}

Transaction defines the JSON format of a Sentry transactionJob, NOTE: this is just part of a Sentry Event, if we need to emit other Events convert this structure into an Event struct and add the other fields to it .

type TransactionJob 

type TransactionJob struct {
	// NumProjects to use in the requests
	NumProjects int `json:"numProjects" yaml:"numProjects"`
	// TransactionTimestampSpread the spread (from Now) of the timestamp, generated transactions will have timestamps between
	// `Now` and `Now-TransactionTimestampSpread`
	TransactionTimestampSpread utils.StringDuration `json:"transactionTimestampSpread,omitempty" yaml:"transactionTimestampSpread,omitempty"`
	// TransactionJobCommon embedded fields, see TransactionJobCommon documentation
	TransactionJobCommon `yaml:"transactionJobCommon,inline"`
}

TransactionJob is how a transactionJob load test is parameterized example: ```json 

{
 "numProjects": 10000,
 "transactionDurationMax":"10m" ,
 "transactionDurationMin": "1m" ,
 "transactionTimestampSpread": "5h" ,
 "minSpans": 5,
 "maxSpans": 40,
 "numReleases": 1000 ,
 "numUsers": 2000,
 "minBreadcrumbs": 5,
 "maxBreadcrumbs": 25,
 "breadcrumbCategories": ["auth", "web-request", "query"],
 "breadcrumbLevels": ["fatal", "error", "warning", "info", "debug"],
 "breadcrumbsTypes": ["default", "http", "error"] ,
 "breadcrumbMessages": [ "Authenticating the user_name", "IOError: [Errno 2] No such file"],
 "measurements": ["fp","fcp","lcp","fid","cls","ttfb"],
 "operations": ["browser","http","db","resource.script"]
}

```

type TransactionJobCommon 

type TransactionJobCommon struct {
	// TransactionDurationMax the maximum duration for a transactionJob
	TransactionDurationMax utils.StringDuration `json:"transactionDurationMax,omitempty" yaml:"transactionDurationMax,omitempty"`
	// TransactionDurationMin the minimum duration for a transactionJob
	TransactionDurationMin utils.StringDuration `json:"transactionDurationMin,omitempty" yaml:"transactionDurationMin,omitempty"`
	// MinSpans specifies the minimum number of spans generated in a transactionJob
	MinSpans uint64 `json:"minSpans,omitempty" yaml:"minSpans,omitempty"`
	// MaxSpans specifies the maximum number of spans generated in a transactionJob
	MaxSpans uint64 `json:"maxSpans,omitempty" yaml:"maxSpans,omitempty"`
	// NumReleases specifies the maximum number of unique releases generated in a test
	NumReleases uint64 `json:"numReleases,omitempty" yaml:"numReleases,omitempty"`
	// NumUsers specifies the maximum number of unique users generated in a test
	NumUsers uint64 `json:"numUsers,omitempty" yaml:"numUsers,omitempty"`
	// MinBreadcrumbs specifies the minimum number of breadcrumbs that will be generated in a test
	MinBreadcrumbs uint64 `json:"minBreadcrumbs,omitempty" yaml:"minBreadcrumbs,omitempty"`
	// MaxBreadcrumbs specifies the maximum number of breadcrumbs that will be generated in a test
	MaxBreadcrumbs uint64 `json:"maxBreadcrumbs,omitempty" yaml:"maxBreadcrumbs,omitempty"`
	// BreadcrumbCategories the categories used for breadcrumbs (if not specified defaults will be used *)
	BreadcrumbCategories []string `json:"breadcrumbCategories,omitempty" yaml:"breadcrumbCategories,omitempty"`
	// BreadcrumbLevels specifies levels used for breadcrumbs (if not specified defaults will be used *)
	BreadcrumbLevels []string `json:"breadcrumbLevels,omitempty" yaml:"breadcrumbLevels,omitempty"`
	// BreadcrumbsTypes specifies the types used for breadcrumbs (if not specified defaults will be used *)
	BreadcrumbsTypes []string `json:"breadcrumbsTypes,omitempty" yaml:"breadcrumbsTypes,omitempty"`
	// BreadcrumbMessages specifies messages set in breadcrumbs (if not specified defaults will be used *)
	BreadcrumbMessages []string `json:"breadcrumbMessages,omitempty" yaml:"breadcrumbMessages,omitempty"`
	// Measurements specifies measurements to be used (if not specified NO measurements will be generated)
	Measurements []string `json:"measurements,omitempty" yaml:"measurements,omitempty"`
	// Operations specifies the operations to be used (if not specified NO operations will be generated)
	Operations []string `json:"operations,omitempty" yaml:"operations,omitempty"`
}

TransactionJobCommon represents the common parameters for transactions jobs (both V1 and V2) NOTE: No YAML support (yaml unlike json does not flatten embedded structures)

type TransactionJobV2 

type TransactionJobV2 struct {
	// The project profiles
	ProjectDistribution []ProjectProfile `json:"projectDistribution" yaml:"projectDistribution"`
	// TransactionJobCommon embedded fields, see TransactionJobCommon documentation
	TransactionJobCommon `yaml:"transactionJobCommon,inline"`
}

TransactionJobV2 is how a transactionJobV2 load test is parameterized example: ```json 

{
 "projectDistribution": [
   {
     "numProjects": 100,
     "relativeFreqWeight" : 1.0,
     "timestampHistogram": [
       { "weight": 5, "maxDelay": "1s"},
       { "weight": 3, "maxDelay": "10s"},
       { "weight": 2, "maxDelay": "20s"},
     ]
   },
   {
     "numProjects": 200,
     "relativeFreqWeight" : 4.0,
     "timestampHistogram": [
       { "weight": 20, "maxDelay": "1s"},
       { "weight": 1, "maxDelay": "5s"}
     ]
   }
 ],
 "transactionDurationMax":"10m" ,
 "transactionDurationMin": "1m" ,
 "minSpans": 5,
 "maxSpans": 40,
 "numReleases": 1000 ,
 "numUsers": 2000,
 "minBreadcrumbs": 5,
 "maxBreadcrumbs": 25,
 "breadcrumbCategories": ["auth", "web-request", "query"],
 "breadcrumbLevels": ["fatal", "error", "warning", "info", "debug"],
 "breadcrumbsTypes": ["default", "http", "error"] ,
 "breadcrumbMessages": [ "Authenticating the user_name", "IOError: [Errno 2] No such file"],
 "measurements": ["fp","fcp","lcp","fid","cls","ttfb"],
 "operations": ["browser","http","db","resource.script"]
}

```

type User 

type User struct {
	IpAddress string `json:"ip_address,omitempty"`
	Username  string `json:"username,omitempty"`
	Id        string `json:"id,omitempty"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.