import "github.com/bojand/ghz/runner"
call_template_data.go data.go options.go reason.go reporter.go requester.go run.go stats_handler.go worker.go
const (
// ReasonNormalEnd indicates a normal end to the run
ReasonNormalEnd = StopReason("normal")
// ReasonCancel indicates end due to cancellation
ReasonCancel = StopReason("cancel")
// ReasonTimeout indicates run ended due to Z parameter timeout
ReasonTimeout = StopReason("timeout")
)type Bucket struct {
// The Mark for histogram bucket in seconds
Mark float64 `json:"mark"`
// The count in the bucket
Count int `json:"count"`
// The frequency of results in the bucket as a decimal percentage
Frequency float64 `json:"frequency"`
}Bucket holds histogram data
type LatencyDistribution struct {
Percentage int `json:"percentage"`
Latency time.Duration `json:"latency"`
}LatencyDistribution holds latency distribution data
Option controls some aspect of run
WithAuthority specifies the value to be used as the :authority pseudo-header. This only works with WithInsecure option.
WithBinaryData specifies the binary data
msg := &helloworld.HelloRequest{}
msg.Name = "bob"
binData, _ := proto.Marshal(msg)
WithBinaryData(binData)
WithBinaryDataFromFile specifies the binary data
WithBinaryDataFromFile("request_data.bin")
WithCPUs specifies the number of CPU's to be used
WithCPUs(4)
WithCertificate specifies the certificate options for the run
WithCertificate("client.crt", "client.key")
WithConcurrency specifies the C (number of concurrent requests) option
WithConcurrency(20)
WithConnections specifies the number of gRPC connections to use
WithConnections(5)
WithData specifies data as generic data that can be serailized to JSON
WithDataFromFile loads JSON data from file
WithDataFromFile("data.json")
WithDataFromJSON loads JSON data from string
WithDataFromJSON(`{"name":"bob"}`)
WithDataFromReader loads JSON data from reader
file, _ := os.Open("data.json")
WithDataFromReader(file)
WithDialTimeout specifies the initial connection dial timeout
WithDialTimeout(time.Duration(20*time.Second))
WithInsecure specifies that this run should be done using insecure mode
WithInsecure(true)
WithKeepalive specifies the keepalive timeout
WithKeepalive(time.Duration(1*time.Minute))
WithMetadata specifies the metadata to be used as a map
md := make(map[string]string) md["token"] = "foobar" md["request-id"] = "123" WithMetadata(&md)
WithMetadataFromFile loads JSON metadata from file
WithMetadataFromJSON("metadata.json")
WithMetadataFromJSON specifies the metadata to be read from JSON string
WithMetadataFromJSON(`{"request-id":"123"}`)
WithName sets the name of the test run
WithName("greeter service test")
WithProtoFile specified proto file path and optionally import paths We will automatically add the proto file path's directory and the current directory
WithProtoFile("greeter.proto", []string{"/home/protos"})
WithProtoset specified protoset file path
WithProtoset("bundle.protoset")
WithQPS specifies the QPS (queries per second) limit option
WithQPS(10)
WithReflectionMetadata specifies the metadata to be used as a map
md := make(map[string]string) md["token"] = "foobar" md["request-id"] = "123" WithReflectionMetadata(&md)
WithRootCertificate specifies the root certificate options for the run
WithRootCertificate("ca.crt")
WithRunDuration specifies the Z (total test duration) option
WithRunDuration(time.Duration(2*time.Minute))
WithServerNameOverride specifies the certificate options for the run
WithSkipTLSVerify skip client side TLS verification of server certificate
WithStreamInterval sets the stream interval
WithTags specifies the user defined tags as a map
tags := make(map[string]string) tags["env"] = "staging" tags["created by"] = "joe developer" WithTags(&tags)
WithTimeout specifies the timeout for each request
WithTimeout(time.Duration(20*time.Second))
WithTotalRequests specifies the N (number of total requests) setting
WithTotalRequests(1000)
type Options struct {
Host string `json:"host,omitempty"`
Proto string `json:"proto,omitempty"`
Protoset string `json:"protoset,omitempty"`
ImportPaths []string `json:"import-paths,omitempty"`
Call string `json:"call,omitempty"`
CACert string `json:"cacert,omitempty"`
Cert string `json:"cert,omitempty"`
Key string `json:"key,omitempty"`
SkipTLS bool `json:"skipTLS,omitempty"`
CName string `json:"cname,omitempty"`
Authority string `json:"authority,omitempty"`
Insecure bool `json:"insecure"`
Total uint `json:"total,omitempty"`
Concurrency uint `json:"concurrency,omitempty"`
QPS uint `json:"qps,omitempty"`
Connections uint `json:"connections,omitempty"`
Duration time.Duration `json:"duration,omitempty"`
Timeout time.Duration `json:"timeout,omitempty"`
DialTimeout time.Duration `json:"dial-timeout,omitempty"`
KeepaliveTime time.Duration `json:"keepalive,omitempty"`
Data interface{} `json:"data,omitempty"`
Binary bool `json:"binary"`
Metadata *map[string]string `json:"metadata,omitempty"`
CPUs int `json:"CPUs"`
Name string `json:"name,omitempty"`
}Options represents the request options
type Report struct {
Name string `json:"name,omitempty"`
EndReason StopReason `json:"endReason,omitempty"`
Options Options `json:"options,omitempty"`
Date time.Time `json:"date"`
Count uint64 `json:"count"`
Total time.Duration `json:"total"`
Average time.Duration `json:"average"`
Fastest time.Duration `json:"fastest"`
Slowest time.Duration `json:"slowest"`
Rps float64 `json:"rps"`
ErrorDist map[string]int `json:"errorDistribution"`
StatusCodeDist map[string]int `json:"statusCodeDistribution"`
LatencyDistribution []LatencyDistribution `json:"latencyDistribution"`
Histogram []Bucket `json:"histogram"`
Details []ResultDetail `json:"details"`
Tags map[string]string `json:"tags,omitempty"`
}Report holds the data for the full test
Run executes the test
report, err := runner.Run(
"helloworld.Greeter.SayHello",
"localhost:50051",
WithProtoFile("greeter.proto", []string{}),
WithDataFromFile("data.json"),
WithInsecure(true),
)
ExampleRun demonstrates how to use runner package to perform a gRPC load test programmatically. We use the printer package to print the report in pretty JSON format.
Code:
report, err := runner.Run(
"helloworld.Greeter.SayHello",
"localhost:50051",
runner.WithProtoFile("greeter.proto", []string{}),
runner.WithDataFromFile("data.json"),
runner.WithInsecure(true),
)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
printer := printer.ReportPrinter{
Out: os.Stdout,
Report: report,
}
printer.Print("pretty")
MarshalJSON is custom marshal for report to properly format the date
type Reporter struct {
// contains filtered or unexported fields
}Reporter gathers all the results
Finalize all the gathered data into a final report
Run runs the reporter
type Requester struct {
// contains filtered or unexported fields
}Requester is used for doing the requests
Finish finishes the test run
Run makes all the requests and returns a report of results It blocks until all work is done.
func (b *Requester) Stop(reason StopReason)
Stop stops the test
type ResultDetail struct {
Timestamp time.Time `json:"timestamp"`
Latency time.Duration `json:"latency"`
Error string `json:"error"`
Status string `json:"status"`
}ResultDetail data for each result
type RunConfig struct {
// contains filtered or unexported fields
}RunConfig represents the request Configs
StopReason is a reason why the run ended
func ReasonFromString(str string) StopReason
ReasonFromString creates a Status from a string
func (s StopReason) MarshalJSON() ([]byte, error)
MarshalJSON formats a Threshold value into a JSON string
func (s StopReason) String() string
String() is the string representation of threshold
func (s *StopReason) UnmarshalJSON(b []byte) error
UnmarshalJSON prases a Threshold value from JSON string
type Worker struct {
// contains filtered or unexported fields
}Worker is used for doing a single stream of requests in parallel
Package runner imports 35 packages (graph) and is imported by 2 packages. Updated 2019-07-05. Refresh now. Tools for package owners.