boomer

README

boomer

This module is initially forked from myzhan/boomer and made a lot of changes.

Documentation

Index

• Variables
• func SetUlimit(limit uint64)
• type Boomer
  • func NewStandaloneBoomer(spawnCount int, spawnRate float64) *Boomer
  • func (b *Boomer) AddOutput(o Output)
  • func (b *Boomer) EnableCPUProfile(cpuProfile string, duration time.Duration)
  • func (b *Boomer) EnableGracefulQuit()
  • func (b *Boomer) EnableMemoryProfile(memoryProfile string, duration time.Duration)
  • func (b *Boomer) GetDisableCompression() bool
  • func (b *Boomer) GetDisableKeepAlive() bool
  • func (b *Boomer) GetMode() string
  • func (b *Boomer) GetSpawnCount() int
  • func (b *Boomer) GetSpawnDoneChan() chan struct{}
  • func (b *Boomer) Quit()
  • func (b *Boomer) RecordFailure(requestType, name string, responseTime int64, exception string)
  • func (b *Boomer) RecordSuccess(requestType, name string, responseTime int64, responseLength int64)
  • func (b *Boomer) RecordTransaction(name string, success bool, elapsedTime int64, contentSize int64)
  • func (b *Boomer) ResetStartTime()
  • func (b *Boomer) Run(tasks ...*Task)
  • func (b *Boomer) SetDisableCompression(disableCompression bool)
  • func (b *Boomer) SetDisableKeepAlive(disableKeepalive bool)
  • func (b *Boomer) SetLoopCount(loopCount int64)
  • func (b *Boomer) SetMode(mode Mode)
  • func (b *Boomer) SetRateLimiter(maxRPS int64, requestIncreaseRate string)
• type ConsoleOutput
  • func NewConsoleOutput() *ConsoleOutput
  • func (o *ConsoleOutput) OnEvent(data map[string]interface{})
  • func (o *ConsoleOutput) OnStart()
  • func (o *ConsoleOutput) OnStop()
• type Loop
• type Mode
• type Output
• type PrometheusPusherOutput
  • func NewPrometheusPusherOutput(gatewayURL, jobName string, mode string) *PrometheusPusherOutput
  • func (o *PrometheusPusherOutput) OnEvent(data map[string]interface{})
  • func (o *PrometheusPusherOutput) OnStart()
  • func (o *PrometheusPusherOutput) OnStop()
• type RampUpRateLimiter
  • func NewRampUpRateLimiter(maxThreshold int64, rampUpRate string, refillPeriod time.Duration) (rateLimiter *RampUpRateLimiter, err error)
  • func (limiter *RampUpRateLimiter) Acquire() (blocked bool)
  • func (limiter *RampUpRateLimiter) Start()
  • func (limiter *RampUpRateLimiter) Stop()
• type RateLimiter
• type StableRateLimiter
  • func NewStableRateLimiter(threshold int64, refillPeriod time.Duration) (rateLimiter *StableRateLimiter)
  • func (limiter *StableRateLimiter) Acquire() (blocked bool)
  • func (limiter *StableRateLimiter) Start()
  • func (limiter *StableRateLimiter) Stop()
• type Task

Variables

var ErrParsingRampUpRate = errors.New("ratelimiter: invalid format of rampUpRate, try \"1\" or \"1/1s\"")

ErrParsingRampUpRate is the error returned if the format of rampUpRate is invalid.

Functions

func SetUlimit

func SetUlimit(limit uint64)

set resource limit ulimit -n 10240

Types

type Boomer

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

A Boomer is used to run tasks.

func NewStandaloneBoomer

func NewStandaloneBoomer(spawnCount int, spawnRate float64) *Boomer

NewStandaloneBoomer returns a new Boomer, which can run without master.

func (*Boomer) AddOutput

func (b *Boomer) AddOutput(o Output)

AddOutput accepts outputs which implements the boomer.Output interface.

func (*Boomer) EnableCPUProfile

func (b *Boomer) EnableCPUProfile(cpuProfile string, duration time.Duration)

EnableCPUProfile will start cpu profiling after run.

func (*Boomer) EnableGracefulQuit

func (b *Boomer) EnableGracefulQuit()

EnableGracefulQuit catch SIGINT and SIGTERM signals to quit gracefully

func (*Boomer) EnableMemoryProfile

func (b *Boomer) EnableMemoryProfile(memoryProfile string, duration time.Duration)

EnableMemoryProfile will start memory profiling after run.

func (*Boomer) GetDisableCompression

func (b *Boomer) GetDisableCompression() bool

func (*Boomer) GetDisableKeepAlive

func (b *Boomer) GetDisableKeepAlive() bool

func (*Boomer) GetMode

func (b *Boomer) GetMode() string

GetMode returns boomer operating mode

func (*Boomer) GetSpawnCount

func (b *Boomer) GetSpawnCount() int

func (*Boomer) GetSpawnDoneChan

func (b *Boomer) GetSpawnDoneChan() chan struct{}

func (*Boomer) Quit

func (b *Boomer) Quit()

Quit will send a quit message to the master.

func (*Boomer) RecordFailure

func (b *Boomer) RecordFailure(requestType, name string, responseTime int64, exception string)

RecordFailure reports a failure.

func (*Boomer) RecordSuccess

func (b *Boomer) RecordSuccess(requestType, name string, responseTime int64, responseLength int64)

RecordSuccess reports a success.

func (*Boomer) RecordTransaction

func (b *Boomer) RecordTransaction(name string, success bool, elapsedTime int64, contentSize int64)

RecordTransaction reports a transaction stat.

func (*Boomer) ResetStartTime

func (b *Boomer) ResetStartTime()

func (*Boomer) Run

func (b *Boomer) Run(tasks ...*Task)

Run accepts a slice of Task and connects to the locust master.

func (*Boomer) SetDisableCompression

func (b *Boomer) SetDisableCompression(disableCompression bool)

SetDisableCompression disable compression to prevent the Transport from requesting compression with an "Accept-Encoding: gzip"

func (*Boomer) SetDisableKeepAlive

func (b *Boomer) SetDisableKeepAlive(disableKeepalive bool)

SetDisableKeepAlive disable keep-alive for tcp

func (*Boomer) SetLoopCount

func (b *Boomer) SetLoopCount(loopCount int64)

SetLoopCount set loop count for test.

func (*Boomer) SetMode

func (b *Boomer) SetMode(mode Mode)

SetMode only accepts boomer.DistributedMasterMode、boomer.DistributedWorkerMode and boomer.StandaloneMode.

func (*Boomer) SetRateLimiter

func (b *Boomer) SetRateLimiter(maxRPS int64, requestIncreaseRate string)

SetRateLimiter creates rate limiter with the given limit and burst.

type ConsoleOutput

type ConsoleOutput struct{}

ConsoleOutput is the default output for standalone mode.

func NewConsoleOutput

func NewConsoleOutput() *ConsoleOutput

NewConsoleOutput returns a ConsoleOutput.

func (*ConsoleOutput) OnEvent

func (o *ConsoleOutput) OnEvent(data map[string]interface{})

OnEvent will print to the console.

func (*ConsoleOutput) OnStart

func (o *ConsoleOutput) OnStart()

OnStart of ConsoleOutput has nothing to do.

func (*ConsoleOutput) OnStop

func (o *ConsoleOutput) OnStop()

OnStop of ConsoleOutput has nothing to do.

type Loop

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

type Mode

type Mode int

Mode is the running mode of boomer, both standalone and distributed are supported.

const (
	// DistributedMasterMode requires being connected by each worker.
	DistributedMasterMode Mode = iota
	// DistributedWorkerMode requires connecting to a master.
	DistributedWorkerMode
	// StandaloneMode will run without a master.
	StandaloneMode
)

type Output

type Output interface {
	// OnStart will be call before the test starts.
	OnStart()

	// By default, each output receive stats data from runner every three seconds.
	// OnEvent is responsible for dealing with the data.
	OnEvent(data map[string]interface{})

	// OnStop will be called before the test ends.
	OnStop()
}

Output is primarily responsible for printing test results to different destinations such as consoles, files. You can write you own output and add to boomer. When running in standalone mode, the default output is ConsoleOutput, you can add more. When running in distribute mode, test results will be reported to master with or without an output. All the OnXXX function will be call in a separated goroutine, just in case some output will block. But it will wait for all outputs return to avoid data lost.

type PrometheusPusherOutput

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

PrometheusPusherOutput pushes boomer stats to Prometheus Pushgateway.

func NewPrometheusPusherOutput

func NewPrometheusPusherOutput(gatewayURL, jobName string, mode string) *PrometheusPusherOutput

NewPrometheusPusherOutput returns a PrometheusPusherOutput.

func (*PrometheusPusherOutput) OnEvent

func (o *PrometheusPusherOutput) OnEvent(data map[string]interface{})

OnEvent will push metric to Prometheus Pushgataway

func (*PrometheusPusherOutput) OnStart

func (o *PrometheusPusherOutput) OnStart()

OnStart will register all prometheus metric collectors

func (*PrometheusPusherOutput) OnStop

func (o *PrometheusPusherOutput) OnStop()

OnStop of PrometheusPusherOutput has nothing to do.

type RampUpRateLimiter

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

A RampUpRateLimiter uses the token bucket algorithm. the threshold is updated according to the warm up rate. the bucket is refilled according to the refill period, no burst is allowed.

func NewRampUpRateLimiter

func NewRampUpRateLimiter(maxThreshold int64, rampUpRate string, refillPeriod time.Duration) (rateLimiter *RampUpRateLimiter, err error)

NewRampUpRateLimiter returns a RampUpRateLimiter. Valid formats of rampUpRate are "1", "1/1s".

func (*RampUpRateLimiter) Acquire

func (limiter *RampUpRateLimiter) Acquire() (blocked bool)

Acquire a token from the bucket, returns true if the bucket is exhausted.

func (*RampUpRateLimiter) Start

func (limiter *RampUpRateLimiter) Start()

Start to refill the bucket periodically.

func (*RampUpRateLimiter) Stop

func (limiter *RampUpRateLimiter) Stop()

Stop the rate limiter.

type RateLimiter

type RateLimiter interface {
	// Start is used to enable the rate limiter.
	// It can be implemented as a noop if not needed.
	Start()

	// Acquire() is called before executing a task.Fn function.
	// If Acquire() returns true, the task.Fn function will be executed.
	// If Acquire() returns false, the task.Fn function won't be executed this time, but Acquire() will be called very soon.
	// It works like:
	// for {
	//      blocked := rateLimiter.Acquire()
	//      if !blocked {
	//	        task.Fn()
	//      }
	// }
	// Acquire() should block the caller until execution is allowed.
	Acquire() bool

	// Stop is used to disable the rate limiter.
	// It can be implemented as a noop if not needed.
	Stop()
}

RateLimiter is used to put limits on task executions.

type StableRateLimiter

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

A StableRateLimiter uses the token bucket algorithm. the bucket is refilled according to the refill period, no burst is allowed.

func NewStableRateLimiter

func NewStableRateLimiter(threshold int64, refillPeriod time.Duration) (rateLimiter *StableRateLimiter)

NewStableRateLimiter returns a StableRateLimiter.

func (*StableRateLimiter) Acquire

func (limiter *StableRateLimiter) Acquire() (blocked bool)

Acquire a token from the bucket, returns true if the bucket is exhausted.

func (*StableRateLimiter) Start

func (limiter *StableRateLimiter) Start()

Start to refill the bucket periodically.

func (*StableRateLimiter) Stop

func (limiter *StableRateLimiter) Stop()

Stop the rate limiter.

type Task

type Task struct {
	// The weight is used to distribute goroutines over multiple tasks.
	Weight int
	// Fn is called by the goroutines allocated to this task, in a loop.
	Fn   func()
	Name string
}

Task is like the "Locust object" in locust, the python version. When boomer receives a start message from master, it will spawn several goroutines to run Task.Fn. But users can keep some information in the python version, they can't do the same things in boomer. Because Task.Fn is a pure function.