diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..51ed1a8 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,25 @@ +name: ci + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + +jobs: + + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + + - name: Set up Go + uses: actions/setup-go@v2 + with: + go-version: 1.14 + + - name: Build + run: go build -v + + - name: Test + run: go test -v diff --git a/README.md b/README.md index f1436f8..8c9c1d6 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,5 @@ +![ci](https://github.com/pinpoint-apm/pinpoint-go-agent/workflows/ci/badge.svg) + # Pinpoint Go Agent Pinpoint Go Agent is a library that allows Go applications to be monitored through pinpoint. @@ -19,6 +21,7 @@ import pinpoint "github.com/pinpoint-apm/pinpoint-go-agent" ## Requirements * Go 1.12+ * Pinpoint 2.1.1+ +* support Linux only ## Example diff --git a/agent.go b/agent.go index 10e0d61..df35856 100644 --- a/agent.go +++ b/agent.go @@ -31,17 +31,19 @@ func log(srcFile string) *logrus.Entry { return logger.WithFields(logrus.Fields{"module": "pinpoint", "src": srcFile}) } -type Agent struct { - config Config - startTime int64 - sequence int64 - agentGrpc *agentGrpc - spanGrpc *spanGrpc - statGrpc *statGrpc - cmdGrpc *cmdGrpc - spanChan chan *span - wg sync.WaitGroup - sampler traceSampler +type agent struct { + config Config + startTime int64 + sequence int64 + agentGrpc *agentGrpc + spanGrpc *spanGrpc + statGrpc *statGrpc + cmdGrpc *cmdGrpc + spanBuffer []*span + spanChan chan *span + metaChan chan interface{} + wg sync.WaitGroup + sampler traceSampler exceptionIdCache *lru.Cache exceptionIdGen int32 @@ -49,17 +51,41 @@ type Agent struct { sqlIdGen int32 apiCache *lru.Cache apiIdGen int32 - metaMutex sync.Mutex + + spanStream *spanStream + spanStreamReq bool + spanStreamReqCount uint64 + + statStream *statStream + statStreamReq bool + statStreamReqCount uint64 enable bool } -func NewAgent(config *Config) (*Agent, error) { +type apiMeta struct { + id int32 + descriptor string + apiType int +} + +type stringMeta struct { + id int32 + funcname string +} + +type sqlMeta struct { + id int32 + sql string +} + +func NewAgent(config *Config) (Agent, error) { + agent := agent{} + if config == nil { - return nil, errors.New("configuration is missing") + return &agent, errors.New("configuration is missing") } - agent := Agent{} agent.config = *config agent.startTime = time.Now().UnixNano() / int64(time.Millisecond) agent.sequence = 0 @@ -71,43 +97,25 @@ func NewAgent(config *Config) (*Agent, error) { } var err error - agent.agentGrpc, err = newAgentGrpc(&agent) - if err != nil { - return nil, err - } - - agent.spanGrpc, err = newSpanGrpc(&agent) - if err != nil { - return nil, err - } - agent.spanChan = make(chan *span, 10*1024) - - agent.statGrpc, err = newStatGrpc(&agent) - if err != nil { - return nil, err - } - - agent.cmdGrpc, err = newCommandGrpc(&agent) - if err != nil { - return nil, err - } + agent.spanChan = make(chan *span, 5*1024) + agent.metaChan = make(chan interface{}, 1*1024) agent.exceptionIdGen = 0 agent.exceptionIdCache, err = lru.New(cacheSize) if err != nil { - return nil, err + return &agent, err } agent.sqlIdGen = 0 agent.sqlCache, err = lru.New(cacheSize) if err != nil { - return nil, err + return &agent, err } agent.apiIdGen = asyncApiId agent.apiCache, err = lru.New(cacheSize) if err != nil { - return nil, err + return &agent, err } baseSampler := newRateSampler(uint64(config.Sampling.Rate)) @@ -117,21 +125,80 @@ func NewAgent(config *Config) (*Agent, error) { agent.sampler = newBasicTraceSampler(baseSampler) } - agent.enable = true - agent.agentGrpc.sendAgentInfo() - agent.agentGrpc.sendApiMetadata(asyncApiId, "Asynchronous Invocation", -1, ApiTypeInvocation) + if !config.OffGrpc { + go connectGrpc(&agent) + } + return &agent, nil +} + +func connectGrpc(agent *agent) { + var err error + for true { + agent.agentGrpc, err = newAgentGrpc(agent) + if err != nil { + continue + } + + agent.spanGrpc, err = newSpanGrpc(agent) + if err != nil { + agent.agentGrpc.close() + continue + } + + agent.statGrpc, err = newStatGrpc(agent) + if err != nil { + agent.agentGrpc.close() + agent.spanGrpc.close() + continue + } + + agent.cmdGrpc, err = newCommandGrpc(agent) + if err != nil { + agent.agentGrpc.close() + agent.spanGrpc.close() + agent.statGrpc.close() + continue + } + + break + } + + for true { + err = agent.agentGrpc.sendAgentInfo() + if err == nil { + break + } + time.Sleep(1 * time.Second) + } + + for true { + err = agent.agentGrpc.sendApiMetadata(asyncApiId, "Asynchronous Invocation", -1, ApiTypeInvocation) + if err == nil { + break + } + time.Sleep(1 * time.Second) + } + + agent.enable = true go agent.sendPingWorker() go agent.sendSpanWorker() - go collectStats(&agent) - go commandService(&agent) + go agent.sendStatsWorker() + go agent.runCommandService() + go agent.sendMetaWorker() - agent.wg.Add(4) + agent.spanStreamReq = false + agent.spanStreamReqCount = 0 + go agent.spanStreamMonitor() - return &agent, nil + agent.statStreamReq = false + agent.statStreamReqCount = 0 + go agent.statStreamMonitor() + + agent.wg.Add(7) } -func (agent *Agent) Shutdown() { +func (agent *agent) Shutdown() { if !agent.enable { return } @@ -147,7 +214,7 @@ func (agent *Agent) Shutdown() { agent.statGrpc.close() } -func (agent *Agent) NewSpanTracer(operation string) Tracer { +func (agent *agent) NewSpanTracer(operation string) Tracer { var tracer Tracer if agent.enable { @@ -160,7 +227,7 @@ func (agent *Agent) NewSpanTracer(operation string) Tracer { return tracer } -func (agent *Agent) NewSpanTracerWithReader(operation string, reader DistributedTracingContextReader) Tracer { +func (agent *agent) NewSpanTracerWithReader(operation string, reader DistributedTracingContextReader) Tracer { if !agent.enable { return newNoopSpan(agent) } @@ -199,20 +266,32 @@ func (agent *Agent) NewSpanTracerWithReader(operation string, reader Distributed return tracer } -func (agent *Agent) RegisterSpanApiId(descriptor string, apiType int) int32 { +func (agent *agent) RegisterSpanApiId(descriptor string, apiType int) int32 { if !agent.enable { return 0 } - id := agent.cacheSpanApiId(descriptor, apiType) + id := agent.CacheSpanApiId(descriptor, apiType) return id } -func (agent *Agent) generateTransactionId() TransactionId { +func (agent *agent) Config() Config { + return agent.config +} + +func (agent *agent) GenerateTransactionId() TransactionId { return TransactionId{agent.config.AgentId, agent.startTime, agent.sequence} } -func (agent *Agent) sendPingWorker() { +func (agent *agent) Enable() bool { + return agent.enable +} + +func (agent *agent) StartTime() int64 { + return agent.startTime +} + +func (agent *agent) sendPingWorker() { log("agent").Info("ping goroutine start") defer agent.wg.Done() stream := agent.agentGrpc.newPingStreamWithRetry() @@ -236,29 +315,33 @@ func (agent *Agent) sendPingWorker() { log("agent").Info("ping goroutine finish") } -func (agent *Agent) sendSpanWorker() { +func (agent *agent) sendSpanWorker() { log("agent").Info("span goroutine start") defer agent.wg.Done() - stream := agent.spanGrpc.newSpanStreamWithRetry() + agent.spanStream = agent.spanGrpc.newSpanStreamWithRetry() for span := range agent.spanChan { if !agent.enable { - continue + break } - err := stream.sendSpan(span) + agent.spanStreamReq = true + err := agent.spanStream.sendSpan(span) + agent.spanStreamReq = false + agent.spanStreamReqCount++ + if err != nil { log("agent").Errorf("fail to sendSpan(): %v", err) - stream.close() - stream = agent.spanGrpc.newSpanStreamWithRetry() + agent.spanStream.close() + agent.spanStream = agent.spanGrpc.newSpanStreamWithRetry() } } - stream.close() + agent.spanStream.close() log("agent").Info("span goroutine finish") } -func (agent *Agent) tryEnqueueSpan(span *span) bool { +func (agent *agent) TryEnqueueSpan(span *span) bool { if !agent.enable { return false } @@ -267,11 +350,93 @@ func (agent *Agent) tryEnqueueSpan(span *span) bool { case agent.spanChan <- span: return true default: + break + } + + <-agent.spanChan + return false +} + +func (agent *agent) spanStreamMonitor() { + for true { + if !agent.enable { + break + } + + c := agent.spanStreamReqCount + time.Sleep(5 * time.Second) + + if agent.spanStreamReq == true && c == agent.spanStreamReqCount { + agent.spanStream.close() + } + } +} + +func (agent *agent) statStreamMonitor() { + for true { + if !agent.enable { + break + } + + c := agent.statStreamReqCount + time.Sleep(5 * time.Second) + + if agent.statStreamReq == true && c == agent.statStreamReqCount { + agent.statStream.close() + } + } +} + +func (agent *agent) sendMetaWorker() { + log("agent").Info("meta goroutine start") + defer agent.wg.Done() + + for md := range agent.metaChan { + if !agent.enable { + break + } + + var err error + switch md.(type) { + case apiMeta: + api := md.(apiMeta) + err = agent.agentGrpc.sendApiMetadata(api.id, api.descriptor, -1, api.apiType) + break + case stringMeta: + str := md.(stringMeta) + err = agent.agentGrpc.sendStringMetadata(str.id, str.funcname) + break + case sqlMeta: + sql := md.(sqlMeta) + err = agent.agentGrpc.sendSqlMetadata(sql.id, sql.sql) + break + } + + if err != nil { + log("agent").Errorf("fail to sendMetadata(): %v", err) + } + } + + log("agent").Info("meta goroutine finish") +} + +func (agent *agent) tryEnqueueMeta(md interface{}) bool { + if !agent.enable { return false } + + select { + case agent.metaChan <- md: + return true + default: + break + } + + <-agent.metaChan + return false } -func (agent *Agent) cacheErrorFunc(funcname string) int32 { +func (agent *agent) CacheErrorFunc(funcname string) int32 { var id int32 if !agent.enable { @@ -287,15 +452,16 @@ func (agent *Agent) cacheErrorFunc(funcname string) int32 { id = atomic.AddInt32(&agent.exceptionIdGen, 1) agent.exceptionIdCache.Add(funcname, id) - agent.metaMutex.Lock() - defer agent.metaMutex.Unlock() - agent.agentGrpc.sendStringMetadata(id, funcname) + md := stringMeta{} + md.id = id + md.funcname = funcname + agent.tryEnqueueMeta(md) log("agent").Info("cache exception id: ", id, funcname) return id } -func (agent *Agent) cacheSql(sql string) int32 { +func (agent *agent) CacheSql(sql string) int32 { var id int32 if !agent.enable { @@ -311,15 +477,16 @@ func (agent *Agent) cacheSql(sql string) int32 { id = atomic.AddInt32(&agent.sqlIdGen, 1) agent.sqlCache.Add(sql, id) - agent.metaMutex.Lock() - defer agent.metaMutex.Unlock() - agent.agentGrpc.sendSqlMetadata(id, sql) + md := sqlMeta{} + md.id = id + md.sql = sql + agent.tryEnqueueMeta(md) log("agent").Info("cache sql id: ", id, sql) return id } -func (agent *Agent) cacheSpanApiId(descriptor string, apiType int) int32 { +func (agent *agent) CacheSpanApiId(descriptor string, apiType int) int32 { var id int32 if !agent.enable { @@ -337,9 +504,11 @@ func (agent *Agent) cacheSpanApiId(descriptor string, apiType int) int32 { id = atomic.AddInt32(&agent.apiIdGen, 1) agent.apiCache.Add(key, id) - agent.metaMutex.Lock() - defer agent.metaMutex.Unlock() - agent.agentGrpc.sendApiMetadata(id, descriptor, -1, apiType) + md := apiMeta{} + md.id = id + md.descriptor = descriptor + md.apiType = apiType + agent.tryEnqueueMeta(md) log("agent").Info("cache api id: ", id, key) return id diff --git a/agent_test.go b/agent_test.go new file mode 100644 index 0000000..a858bdb --- /dev/null +++ b/agent_test.go @@ -0,0 +1,87 @@ +package pinpoint + +import ( + "github.com/stretchr/testify/assert" + "testing" +) + +func Test_agent_NewSpanTracer(t *testing.T) { + type args struct { + agent Agent + } + + opts := []ConfigOption{ + WithAppName("test"), + WithAgentId("testagent"), + } + c, _ := NewConfig(opts...) + a, _ := NewAgent(c) + agent := a.(*agent) + agent.config.OffGrpc = true + agent.enable = true + + tests := []struct { + name string + args args + }{ + {"1", args{agent}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + agent := tt.args.agent + span := agent.NewSpanTracer("test") + + txid := span.TransactionId() + assert.Equal(t, txid.AgentId, "testagent", "AgentId") + assert.Greater(t, txid.StartTime, int64(0), "StartTime") + assert.Greater(t, txid.Sequence, int64(0), "Sequence") + + spanid := span.SpanId() + assert.NotEqual(t, spanid, int64(0), "spanId") + }) + } +} + +func Test_agent_NewSpanTracerWithReader(t *testing.T) { + type args struct { + agent Agent + reader DistributedTracingContextReader + } + + opts := []ConfigOption{ + WithAppName("test"), + WithAgentId("testagent"), + } + c, _ := NewConfig(opts...) + a, _ := NewAgent(c) + agent := a.(*agent) + agent.config.OffGrpc = true + agent.enable = true + + m := map[string]string{ + HttpTraceId: "t123456^12345^1", + HttpSpanId: "67890", + HttpParentSpanId: "123", + } + + tests := []struct { + name string + args args + }{ + {"1", args{agent, &DistributedTracingContextMap{m}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + agent := tt.args.agent + span := agent.NewSpanTracerWithReader("test", tt.args.reader) + + txid := span.TransactionId() + assert.Equal(t, txid.AgentId, "t123456", "AgentId") + assert.Equal(t, txid.StartTime, int64(12345), "StartTime") + assert.Equal(t, txid.Sequence, int64(1), "Sequence") + + spanid := span.SpanId() + assert.Equal(t, spanid, int64(67890), "spanId") + }) + } +} diff --git a/command.go b/command.go index 860f67a..3b5accf 100644 --- a/command.go +++ b/command.go @@ -10,7 +10,7 @@ import ( var gDump *GoroutineDump -func commandService(agent *Agent) { +func (agent *agent) runCommandService() { log("cmd").Info("command service goroutine start") defer agent.wg.Done() diff --git a/config.go b/config.go index 07a6984..2aaa7af 100644 --- a/config.go +++ b/config.go @@ -35,10 +35,15 @@ type Config struct { CollectInterval int BatchCount int } + + IsContainer bool + OffGrpc bool //for test } type ConfigOption func(*Config) +var setContainer bool + func NewConfig(opts ...ConfigOption) (*Config, error) { config := defaultConfig() @@ -62,9 +67,26 @@ func NewConfig(opts ...ConfigOption) (*Config, error) { log("config").Info("agentId is automatically generated: ", config.AgentId) } + if !setContainer { + config.IsContainer = isContainerEnv() + } + return config, nil } +func isContainerEnv() bool { + _, err := os.Stat("/.dockerenv") + if err == nil || !os.IsNotExist(err) { + return true + } + + if os.Getenv("KUBERNETES_SERVICE_HOST") != "" { + return true + } + + return false +} + func defaultConfig() *Config { config := new(Config) @@ -86,6 +108,10 @@ func defaultConfig() *Config { config.Stat.CollectInterval = 5000 //ms config.Stat.BatchCount = 6 + config.IsContainer = false + setContainer = false + + config.OffGrpc = false return config } @@ -198,6 +224,13 @@ func WithStatBatchCount(count int) ConfigOption { } } +func WithIsContainer(isContainer bool) ConfigOption { + setContainer = true + return func(c *Config) { + c.IsContainer = isContainer + } +} + func (config *Config) String() string { j, _ := json.Marshal(config) return string(j) diff --git a/config_test.go b/config_test.go new file mode 100644 index 0000000..b8eb7f5 --- /dev/null +++ b/config_test.go @@ -0,0 +1,105 @@ +package pinpoint + +import ( + "github.com/stretchr/testify/assert" + "testing" +) + +func TestNewConfig(t *testing.T) { + type args struct { + opts []ConfigOption + } + + opts := []ConfigOption{ + WithAppName("TestApp"), + WithAgentId("TestAgent"), + } + + tests := []struct { + name string + args args + }{ + {"1", args{opts}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c, _ := NewConfig(tt.args.opts...) + assert.Equal(t, c.ApplicationName, "TestApp", "ApplicationName") + assert.Equal(t, c.AgentId, "TestAgent", "AgentId") + }) + } +} + +func TestNewConfig_AppNameMissing(t *testing.T) { + type args struct { + opts []ConfigOption + } + + opts := []ConfigOption{ + WithAgentId("TestAgent"), + } + + tests := []struct { + name string + args args + }{ + {"1", args{opts}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + _, err := NewConfig(tt.args.opts...) + assert.Error(t, err, "error") + }) + } +} + +func TestNewConfig_GenerateAgentId(t *testing.T) { + type args struct { + opts []ConfigOption + } + + opts := []ConfigOption{ + WithAppName("TestApp"), + } + + tests := []struct { + name string + args args + }{ + {"1", args{opts}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c, _ := NewConfig(tt.args.opts...) + assert.Equal(t, c.ApplicationName, "TestApp", "ApplicationName") + assert.NotNil(t, c.AgentId, "AgentId") + }) + } +} + +func TestNewConfig_ReadConfigFile(t *testing.T) { + type args struct { + opts []ConfigOption + } + + opts := []ConfigOption{ + WithAppName("TestApp"), + WithAgentId("TestAgent"), + WithConfigFile("/tmp/pinpoint-config.yaml"), + } + + tests := []struct { + name string + args args + }{ + {"1", args{opts}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c, _ := NewConfig(tt.args.opts...) + assert.Equal(t, c.ApplicationName, "TestApp", "ApplicationName") + assert.Equal(t, c.AgentId, "TestAgent", "AgentId") + assert.Equal(t, c.Collector.Host, "1.2.3.4", "Collector.Host") + }) + } +} diff --git a/example/custom.go b/example/custom.go index e57753e..6ef7751 100644 --- a/example/custom.go +++ b/example/custom.go @@ -12,7 +12,7 @@ import ( ) type handler struct { - agent *pinpoint.Agent + agent pinpoint.Agent } func doRequest(tracer pinpoint.Tracer) (string, error) { diff --git a/go.mod b/go.mod index 37bc1fd..abc2486 100644 --- a/go.mod +++ b/go.mod @@ -11,6 +11,7 @@ require ( github.com/go-redis/redis/v8 v8.0.0-beta.7 github.com/go-sql-driver/mysql v1.5.0 github.com/gocql/gocql v0.0.0-20200815110948-5378c8f664e9 + github.com/golang/mock v1.6.0 github.com/golang/protobuf v1.4.2 github.com/hashicorp/golang-lru v0.5.4 github.com/labstack/echo v3.3.10+incompatible @@ -19,14 +20,12 @@ require ( github.com/mattn/go-colorable v0.1.8 // indirect github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect github.com/sirupsen/logrus v1.6.0 + github.com/stretchr/testify v1.7.0 github.com/tsuna/gohbase v0.0.0-20200820233321-d669aff6255b github.com/x-cray/logrus-prefixed-formatter v0.5.2 go.mongodb.org/mongo-driver v1.3.5 - golang.org/x/net v0.0.0-20200320220750-118fecf932d8 // indirect - golang.org/x/sys v0.0.0-20200321134203-328b4cd54aae // indirect golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1 google.golang.org/genproto v0.0.0-20200319113533-08878b785e9c // indirect google.golang.org/grpc v1.30.0 gopkg.in/yaml.v2 v2.3.0 - github.com/stretchr/testify v1.7.0 ) diff --git a/go.sum b/go.sum index 8d39bac..d8bc19c 100644 --- a/go.sum +++ b/go.sum @@ -91,7 +91,10 @@ github.com/gocql/gocql v0.0.0-20200815110948-5378c8f664e9 h1:SBOCi413wRa7i5ZET6d github.com/gocql/gocql v0.0.0-20200815110948-5378c8f664e9/go.mod h1:DL0ekTmBSTdlNF25Orwt/JMzqIq3EJ4MVa/J/uK64OY= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.4.3 h1:GV+pQPG/EUUbkh47niozDcADz6go/dUwhVzdUQHIVRw= github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= @@ -223,6 +226,7 @@ github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c/go.mod h1:lB8K/P019DLNhe github.com/xdg/stringprep v0.0.0-20180714160509-73f8eece6fdc/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y= github.com/xdg/stringprep v1.0.0 h1:d9X0esnoa3dFsV0FG35rAT0RIhYFlPq7MiP+DW89La0= github.com/xdg/stringprep v1.0.0/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.mongodb.org/mongo-driver v1.3.5 h1:S0ZOruh4YGHjD7JoN7mIsTrNjnQbOjrmgrx6l6pZN7I= go.mongodb.org/mongo-driver v1.3.5/go.mod h1:Ual6Gkco7ZGQw8wE1t4tLnvBsf6yVSM60qW6TgOeJ5c= go.opentelemetry.io/otel v0.7.0 h1:u43jukpwqR8EsyeJOMgrsUgZwVI1e1eVw7yuzRkD1l0= @@ -248,6 +252,8 @@ golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHl golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.4.2 h1:Gz96sIWK3OalVv/I/qNygP42zyoKp3xptRVCWRFEBvo= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -259,6 +265,8 @@ golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200320220750-118fecf932d8 h1:1+zQlQqEEhUeStBTi653GZAnAuivZq/2hz+Iz+OP7rg= golang.org/x/net v0.0.0-20200320220750-118fecf932d8/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 h1:4nGaVu0QrbjT/AK2PRLuQfQuh6DJve+pELhqTdAj3x0= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -266,6 +274,7 @@ golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20190412183630-56d357773e84/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -286,6 +295,11 @@ golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200321134203-328b4cd54aae h1:3tcmuaB7wwSZtelmiv479UjUB+vviwABz7a133ZwOKQ= golang.org/x/sys v0.0.0-20200321134203-328b4cd54aae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007 h1:gG67DSER+11cZvqIMb8S8bt0vZtiN6xWYARwirrOSfE= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -304,9 +318,16 @@ golang.org/x/tools v0.0.0-20190420181800-aa740d480789/go.mod h1:LCzVGOaR6xXOjkQ3 golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190531172133-b3315ee88b7d/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa h1:5E4dL8+NgFOgjwbTKz+OOEGGhP+ectTmF842l6KjupQ= golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.1.1 h1:wGiQel/hW0NnEkJUk8lbzkX2gFJU6PFxf1v5OlCfuOs= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= diff --git a/grpc.go b/grpc.go index 16e7867..e635ab6 100644 --- a/grpc.go +++ b/grpc.go @@ -19,12 +19,12 @@ import ( "google.golang.org/grpc/metadata" ) -func grpcMetadataContext(agent *Agent, socketId int64) context.Context { +func grpcMetadataContext(agent Agent, socketId int64) context.Context { m := map[string]string{} - m["agentid"] = agent.config.AgentId - m["applicationname"] = agent.config.ApplicationName - m["starttime"] = strconv.FormatInt(agent.startTime, 10) + m["agentid"] = agent.Config().AgentId + m["applicationname"] = agent.Config().ApplicationName + m["starttime"] = strconv.FormatInt(agent.StartTime(), 10) if socketId > 0 { m["socketid"] = strconv.FormatInt(socketId, 10) @@ -47,12 +47,56 @@ func backOffSleep(attempt int) { time.Sleep(jitter) } +type AgentGrpcClient interface { + RequestAgentInfo(ctx context.Context, agentinfo *pb.PAgentInfo) (*pb.PResult, error) + PingSession(ctx context.Context) (pb.Agent_PingSessionClient, error) +} + +type agentGrpcClient struct { + client pb.AgentClient +} + +func (agentGrpcClient *agentGrpcClient) RequestAgentInfo(ctx context.Context, agentinfo *pb.PAgentInfo) (*pb.PResult, error) { + result, err := agentGrpcClient.client.RequestAgentInfo(ctx, agentinfo) + return result, err +} + +func (agentGrpcClient *agentGrpcClient) PingSession(ctx context.Context) (pb.Agent_PingSessionClient, error) { + session, err := agentGrpcClient.client.PingSession(ctx) + return session, err +} + +type MetaGrpcClient interface { + RequestApiMetaData(ctx context.Context, in *pb.PApiMetaData) (*pb.PResult, error) + RequestSqlMetaData(ctx context.Context, in *pb.PSqlMetaData) (*pb.PResult, error) + RequestStringMetaData(ctx context.Context, in *pb.PStringMetaData) (*pb.PResult, error) +} + +type metaGrpcClient struct { + client pb.MetadataClient +} + +func (metaGrpcClient *metaGrpcClient) RequestApiMetaData(ctx context.Context, in *pb.PApiMetaData) (*pb.PResult, error) { + result, err := metaGrpcClient.client.RequestApiMetaData(ctx, in) + return result, err +} + +func (metaGrpcClient *metaGrpcClient) RequestSqlMetaData(ctx context.Context, in *pb.PSqlMetaData) (*pb.PResult, error) { + result, err := metaGrpcClient.client.RequestSqlMetaData(ctx, in) + return result, err +} + +func (metaGrpcClient *metaGrpcClient) RequestStringMetaData(ctx context.Context, in *pb.PStringMetaData) (*pb.PResult, error) { + result, err := metaGrpcClient.client.RequestStringMetaData(ctx, in) + return result, err +} + type agentGrpc struct { agentConn *grpc.ClientConn - agentClient pb.AgentClient - metadataClient pb.MetadataClient + agentClient AgentGrpcClient + metadataClient MetaGrpcClient pingSocketId int64 - agent *Agent + agent Agent } var kacp = keepalive.ClientParameters{ @@ -61,7 +105,24 @@ var kacp = keepalive.ClientParameters{ PermitWithoutStream: true, } -func newAgentGrpc(agent *Agent) (*agentGrpc, error) { +func connectToCollectorWithRetry(serverAddr string, opts []grpc.DialOption) (*grpc.ClientConn, error) { + var conn *grpc.ClientConn + var err error + + for n := 1; n < 100; n++ { + log("grpc").Infof("connect to collector: %s", serverAddr) + conn, err = grpc.Dial(serverAddr, opts...) + if err == nil { + break + } + log("grpc").Errorf("fail to dial - %v", err) + backOffSleep(n) + } + + return conn, err +} + +func newAgentGrpc(agent Agent) (*agentGrpc, error) { var opts []grpc.DialOption opts = append(opts, grpc.WithInsecure()) @@ -69,21 +130,18 @@ func newAgentGrpc(agent *Agent) (*agentGrpc, error) { opts = append(opts, grpc.WithBlock()) opts = append(opts, grpc.WithTimeout(3*time.Second)) - serverAddr := fmt.Sprintf("%s:%d", agent.config.Collector.Host, agent.config.Collector.AgentPort) - - log("grpc").Infof("connect to agent collector: %s", serverAddr) - conn, err := grpc.Dial(serverAddr, opts...) + serverAddr := fmt.Sprintf("%s:%d", agent.Config().Collector.Host, agent.Config().Collector.AgentPort) + conn, err := connectToCollectorWithRetry(serverAddr, opts) if err != nil { - log("grpc").Errorf("fail to dial - %v", err) return nil, err } - agentClient := pb.NewAgentClient(conn) - metadataClient := pb.NewMetadataClient(conn) - return &agentGrpc{conn, agentClient, metadataClient, 0, agent}, nil + agentClient := agentGrpcClient{pb.NewAgentClient(conn)} + metadataClient := metaGrpcClient{pb.NewMetadataClient(conn)} + return &agentGrpc{conn, &agentClient, &metadataClient, 0, agent}, nil } -func (agentGrpc *agentGrpc) sendAgentInfo() { +func makeAgentInfo(agent Agent) (context.Context, *pb.PAgentInfo) { var agentinfo pb.PAgentInfo agentinfo.AgentVersion = AgentVersion @@ -95,7 +153,8 @@ func (agentGrpc *agentGrpc) sendAgentInfo() { agentinfo.Hostname = hostname agentinfo.Ip = getOutboundIP().String() - agentinfo.ServiceType = agentGrpc.agent.config.ApplicationType + agentinfo.ServiceType = agent.Config().ApplicationType + agentinfo.Container = agent.Config().IsContainer var svrMeta pb.PServerMetaData svrMeta.ServerInfo = "Go Agent" @@ -103,14 +162,25 @@ func (agentGrpc *agentGrpc) sendAgentInfo() { log("grpc").Infof("send agent information: %s", agentinfo.String()) - ctx := grpcMetadataContext(agentGrpc.agent, -1) - _, err = agentGrpc.agentClient.RequestAgentInfo(ctx, &agentinfo) + ctx := grpcMetadataContext(agent, -1) + + return ctx, &agentinfo +} + +func (agentGrpc *agentGrpc) sendAgentInfo() error { + ctx, agentinfo := makeAgentInfo(agentGrpc.agent) + ctx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + + _, err := agentGrpc.agentClient.RequestAgentInfo(ctx, agentinfo) if err != nil { log("grpc").Errorf("fail to call RequestAgentInfo() - %v", err) } + + return err } -func (agentGrpc *agentGrpc) sendApiMetadata(apiId int32, api string, line int, apiType int) { +func (agentGrpc *agentGrpc) sendApiMetadata(apiId int32, api string, line int, apiType int) error { var apimeta pb.PApiMetaData apimeta.ApiId = apiId apimeta.ApiInfo = api @@ -120,13 +190,18 @@ func (agentGrpc *agentGrpc) sendApiMetadata(apiId int32, api string, line int, a log("grpc").Infof("send API metadata: %s", apimeta.String()) ctx := grpcMetadataContext(agentGrpc.agent, -1) + ctx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + _, err := agentGrpc.metadataClient.RequestApiMetaData(ctx, &apimeta) if err != nil { log("grpc").Errorf("fail to call RequestApiMetaData() - %v", err) } + + return err } -func (agentGrpc *agentGrpc) sendStringMetadata(strId int32, str string) { +func (agentGrpc *agentGrpc) sendStringMetadata(strId int32, str string) error { var strmeta pb.PStringMetaData strmeta.StringId = strId strmeta.StringValue = str @@ -134,13 +209,18 @@ func (agentGrpc *agentGrpc) sendStringMetadata(strId int32, str string) { log("grpc").Infof("send string metadata: %s", strmeta.String()) ctx := grpcMetadataContext(agentGrpc.agent, -1) + ctx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + _, err := agentGrpc.metadataClient.RequestStringMetaData(ctx, &strmeta) if err != nil { log("grpc").Errorf("fail to call RequestStringMetaData() - %v", err) } + + return err } -func (agentGrpc *agentGrpc) sendSqlMetadata(sqlId int32, sql string) { +func (agentGrpc *agentGrpc) sendSqlMetadata(sqlId int32, sql string) error { var sqlmeta pb.PSqlMetaData sqlmeta.SqlId = sqlId sqlmeta.Sql = sql @@ -148,10 +228,15 @@ func (agentGrpc *agentGrpc) sendSqlMetadata(sqlId int32, sql string) { log("grpc").Infof("send SQL metadata: %s", sqlmeta.String()) ctx := grpcMetadataContext(agentGrpc.agent, -1) + ctx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + _, err := agentGrpc.metadataClient.RequestSqlMetaData(ctx, &sqlmeta) if err != nil { log("grpc").Errorf("fail to call RequestSqlMetaData() - %v", err) } + + return err } type pingStream struct { @@ -175,7 +260,7 @@ func (agentGrpc *agentGrpc) newPingStream() *pingStream { func (agentGrpc *agentGrpc) newPingStreamWithRetry() *pingStream { for n := 1; n < 100; n++ { - if !agentGrpc.agent.enable { + if !agentGrpc.agent.Enable() { break } @@ -220,17 +305,53 @@ func getOutboundIP() net.IP { return localAddr.IP } +type SpanGrpcClient interface { + SendSpan(ctx context.Context) (pb.Span_SendSpanClient, error) +} + +type spanGrpcClient struct { + client pb.SpanClient +} + +func (spanGrpcClient *spanGrpcClient) SendSpan(ctx context.Context) (pb.Span_SendSpanClient, error) { + return spanGrpcClient.client.SendSpan(ctx) +} + type spanGrpc struct { spanConn *grpc.ClientConn - spanClient pb.SpanClient - agent *Agent + spanClient SpanGrpcClient + stream SpanStreamInvoker + agent Agent } -type spanStream struct { +type SpanStreamInvoker interface { + Send(*pb.PSpanMessage) error + CloseAndRecv() error + CloseSend() error +} + +type spanStreamInvoker struct { stream pb.Span_SendSpanClient } -func newSpanGrpc(agent *Agent) (*spanGrpc, error) { +func (invoker *spanStreamInvoker) Send(span *pb.PSpanMessage) error { + return invoker.stream.Send(span) +} + +func (invoker *spanStreamInvoker) CloseAndRecv() error { + _, err := invoker.stream.CloseAndRecv() + return err +} + +func (invoker *spanStreamInvoker) CloseSend() error { + return invoker.stream.CloseSend() +} + +type spanStream struct { + stream SpanStreamInvoker +} + +func newSpanGrpc(agent Agent) (*spanGrpc, error) { var opts []grpc.DialOption opts = append(opts, grpc.WithInsecure()) @@ -238,17 +359,14 @@ func newSpanGrpc(agent *Agent) (*spanGrpc, error) { opts = append(opts, grpc.WithBlock()) opts = append(opts, grpc.WithTimeout(3*time.Second)) - serverAddr := fmt.Sprintf("%s:%d", agent.config.Collector.Host, agent.config.Collector.SpanPort) - log("grpc").Infof("connect to span collector: %s", serverAddr) - - conn, err := grpc.Dial(serverAddr, opts...) + serverAddr := fmt.Sprintf("%s:%d", agent.Config().Collector.Host, agent.Config().Collector.SpanPort) + conn, err := connectToCollectorWithRetry(serverAddr, opts) if err != nil { - log("grpc").Errorf("fail to dial - %v", err) return nil, err } - client := pb.NewSpanClient(conn) - return &spanGrpc{conn, client, agent}, nil + client := spanGrpcClient{pb.NewSpanClient(conn)} + return &spanGrpc{conn, &client, nil, agent}, nil } func (spanGrpc *spanGrpc) close() { @@ -269,12 +387,12 @@ func (spanGrpc *spanGrpc) newSpanStream() *spanStream { return &spanStream{nil} } - return &spanStream{stream} + return &spanStream{&spanStreamInvoker{stream}} } func (spanGrpc *spanGrpc) newSpanStreamWithRetry() *spanStream { for n := 1; n < 100; n++ { - if !spanGrpc.agent.enable { + if !spanGrpc.agent.Enable() { break } @@ -289,12 +407,16 @@ func (spanGrpc *spanGrpc) newSpanStreamWithRetry() *spanStream { return &spanStream{nil} } +func (s *spanStream) setStreamInvoker(invoker SpanStreamInvoker) { + s.stream = invoker +} + func (s *spanStream) close() { if s.stream == nil { return } - _, err := s.stream.CloseAndRecv() + err := s.stream.CloseAndRecv() if err != nil { log("grpc").Errorf("fail to close span stream - %v", err) } @@ -353,7 +475,7 @@ func makePSpan(span *span) *pb.PSpanMessage { SpanEvent: spanEventList, Err: int32(span.err), ExceptionInfo: nil, //TODO - ApplicationServiceType: span.agent.config.ApplicationType, + ApplicationServiceType: span.agent.Config().ApplicationType, LoggingTransactionInfo: span.loggingInfo, }, }, @@ -396,7 +518,7 @@ func makePSpanChunk(span *span) *pb.PSpanMessage { KeyTime: span.startTime.UnixNano() / int64(time.Millisecond), EndPoint: span.endPoint, SpanEvent: spanEventList, - ApplicationServiceType: span.agent.config.ApplicationType, + ApplicationServiceType: span.agent.Config().ApplicationType, LocalAsyncId: &pb.PLocalAsyncId{ AsyncId: span.asyncId, Sequence: span.asyncSequence, @@ -454,17 +576,53 @@ func (s *spanStream) sendSpanFinish() { s.stream.CloseSend() } +type StatGrpcClient interface { + SendAgentStat(ctx context.Context) (pb.Stat_SendAgentStatClient, error) +} + +type statGrpcClient struct { + client pb.StatClient +} + +func (statGrpcClient *statGrpcClient) SendAgentStat(ctx context.Context) (pb.Stat_SendAgentStatClient, error) { + return statGrpcClient.client.SendAgentStat(ctx) +} + type statGrpc struct { statConn *grpc.ClientConn - statClient pb.StatClient - agent *Agent + statClient StatGrpcClient + stream StatStreamInvoker + agent Agent } -type statStream struct { +type StatStreamInvoker interface { + Send(*pb.PStatMessage) error + CloseAndRecv() error + CloseSend() error +} + +type statStreamInvoker struct { stream pb.Stat_SendAgentStatClient } -func newStatGrpc(agent *Agent) (*statGrpc, error) { +func (invoker *statStreamInvoker) Send(stat *pb.PStatMessage) error { + return invoker.stream.Send(stat) +} + +func (invoker *statStreamInvoker) CloseAndRecv() error { + _, err := invoker.stream.CloseAndRecv() + return err +} + +func (invoker *statStreamInvoker) CloseSend() error { + return invoker.stream.CloseSend() +} + +type statStream struct { + stream StatStreamInvoker +} + +func newStatGrpc(agent Agent) (*statGrpc, error) { var opts []grpc.DialOption opts = append(opts, grpc.WithInsecure()) @@ -472,17 +630,14 @@ func newStatGrpc(agent *Agent) (*statGrpc, error) { opts = append(opts, grpc.WithBlock()) opts = append(opts, grpc.WithTimeout(3*time.Second)) - serverAddr := fmt.Sprintf("%s:%d", agent.config.Collector.Host, agent.config.Collector.StatPort) - log("grpc").Infof("connect to stat collector: %s", serverAddr) - - conn, err := grpc.Dial(serverAddr, opts...) + serverAddr := fmt.Sprintf("%s:%d", agent.Config().Collector.Host, agent.Config().Collector.StatPort) + conn, err := connectToCollectorWithRetry(serverAddr, opts) if err != nil { - log("grpc").Errorf("fail to dial - %v", err) return nil, err } - client := pb.NewStatClient(conn) - return &statGrpc{conn, client, agent}, nil + client := &statGrpcClient{pb.NewStatClient(conn)} + return &statGrpc{conn, client, nil, agent}, nil } func (statGrpc *statGrpc) close() { @@ -500,12 +655,12 @@ func (statGrpc *statGrpc) newStatStream() *statStream { return &statStream{nil} } - return &statStream{stream} + return &statStream{&statStreamInvoker{stream}} } func (statGrpc *statGrpc) newStatStreamWithRetry() *statStream { for n := 1; n < 100; n++ { - if !statGrpc.agent.enable { + if !statGrpc.agent.Enable() { break } @@ -520,12 +675,16 @@ func (statGrpc *statGrpc) newStatStreamWithRetry() *statStream { return &statStream{nil} } +func (s *statStream) setStreamInvoker(invoker StatStreamInvoker) { + s.stream = invoker +} + func (s *statStream) close() { if s.stream == nil { return } - _, err := s.stream.CloseAndRecv() + err := s.stream.CloseAndRecv() if err != nil { log("grpc").Errorf("fail to close stat stream - %v", err) } @@ -606,7 +765,7 @@ func makePAgentStat(stat *inspectorStats) *pb.PAgentStat { type cmdGrpc struct { agentConn *grpc.ClientConn cmdClient pb.ProfilerCommandServiceClient - agent *Agent + agent Agent } type cmdStream struct { @@ -614,7 +773,7 @@ type cmdStream struct { cmdReq *pb.PCmdRequest } -func newCommandGrpc(agent *Agent) (*cmdGrpc, error) { +func newCommandGrpc(agent Agent) (*cmdGrpc, error) { var opts []grpc.DialOption opts = append(opts, grpc.WithInsecure()) @@ -622,7 +781,7 @@ func newCommandGrpc(agent *Agent) (*cmdGrpc, error) { opts = append(opts, grpc.WithBlock()) opts = append(opts, grpc.WithTimeout(3*time.Second)) - serverAddr := fmt.Sprintf("%s:%d", agent.config.Collector.Host, agent.config.Collector.AgentPort) + serverAddr := fmt.Sprintf("%s:%d", agent.Config().Collector.Host, agent.Config().Collector.AgentPort) log("grpc").Infof("connect to agent collector: %s", serverAddr) conn, err := grpc.Dial(serverAddr, opts...) @@ -651,7 +810,7 @@ func (cmdGrpc *cmdGrpc) newHandleCommandStream() *cmdStream { func (cmdGrpc *cmdGrpc) newCommandStreamWithRetry() *cmdStream { for n := 1; n < 100; n++ { - if !cmdGrpc.agent.enable { + if !cmdGrpc.agent.Enable() { break } diff --git a/grpc_test.go b/grpc_test.go new file mode 100644 index 0000000..53c910c --- /dev/null +++ b/grpc_test.go @@ -0,0 +1,158 @@ +package pinpoint + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func Test_agentGrpc_sendAgentInfo(t *testing.T) { + type args struct { + agent Agent + } + tests := []struct { + name string + args args + }{ + {"1", args{newMockAgent()}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + agent := tt.args.agent.(*mockAgent) + agent.setMockAgentGrpc(t) + err := agent.agentGrpc.sendAgentInfo() + assert.NoError(t, err, "sendAgentInfo") + }) + } +} + +func Test_agentGrpc_sendApiMetadata(t *testing.T) { + type args struct { + agent Agent + } + tests := []struct { + name string + args args + }{ + {"1", args{newMockAgent()}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + agent := tt.args.agent.(*mockAgent) + agent.setMockAgentGrpc(t) + err := agent.agentGrpc.sendApiMetadata(asyncApiId, "Asynchronous Invocation", -1, ApiTypeInvocation) + assert.NoError(t, err, "sendApiMetadata") + }) + } +} + +func Test_agentGrpc_sendSqlMetadata(t *testing.T) { + type args struct { + agent Agent + } + tests := []struct { + name string + args args + }{ + {"1", args{newMockAgent()}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + agent := tt.args.agent.(*mockAgent) + agent.setMockAgentGrpc(t) + err := agent.agentGrpc.sendSqlMetadata(1, "SELECT 1") + assert.NoError(t, err, "sendSqlMetadata") + }) + } +} + +func Test_agentGrpc_sendStringMetadata(t *testing.T) { + type args struct { + agent Agent + } + tests := []struct { + name string + args args + }{ + {"1", args{newMockAgent()}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + agent := tt.args.agent.(*mockAgent) + agent.setMockAgentGrpc(t) + err := agent.agentGrpc.sendStringMetadata(1, "string value") + assert.NoError(t, err, "sendStringMetadata") + }) + } +} + +func Test_pingStream_sendPing(t *testing.T) { + type args struct { + agent Agent + } + tests := []struct { + name string + args args + }{ + {"1", args{newMockAgent()}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + agent := tt.args.agent.(*mockAgent) + agent.setMockAgentGrpc(t) + stream := agent.agentGrpc.newPingStreamWithRetry() + err := stream.sendPing() + assert.NoError(t, err, "sendPing") + }) + } +} + +func Test_spanStream_sendSpan(t *testing.T) { + type args struct { + agent Agent + } + tests := []struct { + name string + args args + }{ + {"1", args{newMockAgent()}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + agent := tt.args.agent.(*mockAgent) + agent.setMockSpanGrpc(t) + stream := agent.spanGrpc.newSpanStreamWithRetry() + stream.setStreamInvoker(agent.spanGrpc.stream) + span := defaultSpan() + span.agent = agent + span.NewSpanEvent("t1") + err := stream.sendSpan(span) + assert.NoError(t, err, "sendSpan") + }) + } +} + +func Test_statStream_sendStat(t *testing.T) { + type args struct { + agent Agent + } + tests := []struct { + name string + args args + }{ + {"1", args{newMockAgent()}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + agent := tt.args.agent.(*mockAgent) + agent.setMockStatGrpc(t) + stream := agent.statGrpc.newStatStreamWithRetry() + stream.setStreamInvoker(agent.statGrpc.stream) + + stats := make([]*inspectorStats, 1) + stats[0] = getStats() + err := stream.sendStats(stats) + assert.NoError(t, err, "sendStats") + }) + } +} diff --git a/mock.go b/mock.go new file mode 100644 index 0000000..1bea5a1 --- /dev/null +++ b/mock.go @@ -0,0 +1,203 @@ +package pinpoint + +import ( + "context" + "testing" + + gomock "github.com/golang/mock/gomock" + pb "github.com/pinpoint-apm/pinpoint-go-agent/protobuf" +) + +type mockAgent struct { + config Config + startTime int64 + sequence int64 + agentGrpc *agentGrpc + spanGrpc *spanGrpc + statGrpc *statGrpc +} + +func newMockAgent() Agent { + agent := mockAgent{} + + agent.config = *defaultConfig() + agent.config.ApplicationName = "mock" + agent.config.AgentId = "m1234" + agent.startTime = 12345 + agent.sequence = 1 + + return &agent +} + +func (agent *mockAgent) setMockAgentGrpc(t *testing.T) { + agent.agentGrpc = newMockAgentGrpc(agent, t) +} + +func (agent *mockAgent) setMockSpanGrpc(t *testing.T) { + agent.spanGrpc = newMockSpanGrpc(agent, t) +} + +func (agent *mockAgent) setMockStatGrpc(t *testing.T) { + agent.statGrpc = newMockStatGrpc(agent, t) +} + +func (agent *mockAgent) Shutdown() { +} + +func (agent *mockAgent) NewSpanTracer(operation string) Tracer { + return newNoopSpan(agent) +} + +func (agent *mockAgent) NewSpanTracerWithReader(operation string, reader DistributedTracingContextReader) Tracer { + return newNoopSpan(agent) +} + +func (agent *mockAgent) RegisterSpanApiId(descriptor string, apiType int) int32 { + return 1 +} + +func (agent *mockAgent) Config() Config { + return agent.config +} + +func (agent *mockAgent) GenerateTransactionId() TransactionId { + return TransactionId{agent.config.AgentId, agent.startTime, agent.sequence} +} + +func (agent *mockAgent) Enable() bool { + return true +} + +func (agent *mockAgent) StartTime() int64 { + return agent.startTime +} + +func (agent *mockAgent) TryEnqueueSpan(span *span) bool { + return true +} + +func (agent *mockAgent) CacheErrorFunc(funcname string) int32 { + return 1 +} + +func (agent *mockAgent) CacheSql(sql string) int32 { + return 1 +} + +func (agent *mockAgent) CacheSpanApiId(descriptor string, apiType int) int32 { + return 1 +} + +//mock grpc + +type mockAgentGrpcClient struct { + client *MockAgentClient +} + +func (agentGrpcClient *mockAgentGrpcClient) RequestAgentInfo(ctx context.Context, agentinfo *pb.PAgentInfo) (*pb.PResult, error) { + _ = agentGrpcClient.client.EXPECT().RequestAgentInfo(gomock.Any(), gomock.Any()).Return(&pb.PResult{Success: true, Message: "success"}, nil) + return nil, nil +} + +func (agentGrpcClient *mockAgentGrpcClient) PingSession(ctx context.Context) (pb.Agent_PingSessionClient, error) { + session, err := agentGrpcClient.client.PingSession(ctx) + return session, err +} + +type mockMetaGrpcClient struct { + client *MockMetadataClient +} + +func (metaGrpcClient *mockMetaGrpcClient) RequestApiMetaData(ctx context.Context, in *pb.PApiMetaData) (*pb.PResult, error) { + _ = metaGrpcClient.client.EXPECT().RequestApiMetaData(gomock.Any(), gomock.Any()).Return(&pb.PResult{Success: true, Message: "success"}, nil) + return nil, nil +} + +func (metaGrpcClient *mockMetaGrpcClient) RequestSqlMetaData(ctx context.Context, in *pb.PSqlMetaData) (*pb.PResult, error) { + _ = metaGrpcClient.client.EXPECT().RequestSqlMetaData(gomock.Any(), gomock.Any()).Return(&pb.PResult{Success: true, Message: "success"}, nil) + return nil, nil +} + +func (metaGrpcClient *mockMetaGrpcClient) RequestStringMetaData(ctx context.Context, in *pb.PStringMetaData) (*pb.PResult, error) { + _ = metaGrpcClient.client.EXPECT().RequestStringMetaData(gomock.Any(), gomock.Any()).Return(&pb.PResult{Success: true, Message: "success"}, nil) + return nil, nil +} + +func newMockAgentGrpc(agent Agent, t *testing.T) *agentGrpc { + ctrl := gomock.NewController(t) + agentClient := mockAgentGrpcClient{NewMockAgentClient(ctrl)} + metadataClient := mockMetaGrpcClient{NewMockMetadataClient(ctrl)} + return &agentGrpc{nil, &agentClient, &metadataClient, -1, agent} +} + +type mockSpanGrpcClient struct { + client *MockSpanClient + stream *MockSpan_SendSpanClient +} + +func (spanGrpcClient *mockSpanGrpcClient) SendSpan(ctx context.Context) (pb.Span_SendSpanClient, error) { + //stream := spanGrpcClient.client.EXPECT().SendSpan(ctx).Return(spanGrpcClient.stream, nil) + return spanGrpcClient.stream, nil +} + +func newMockSpanGrpc(agent Agent, t *testing.T) *spanGrpc { + ctrl := gomock.NewController(t) + stream := NewMockSpan_SendSpanClient(ctrl) + spanClient := mockSpanGrpcClient{NewMockSpanClient(ctrl), stream} + return &spanGrpc{nil, &spanClient, &mockSpanStreamInvoker{stream}, agent} +} + +type mockSpanStreamInvoker struct { + stream *MockSpan_SendSpanClient +} + +func (invoker *mockSpanStreamInvoker) Send(span *pb.PSpanMessage) error { + invoker.stream.EXPECT().Send(gomock.Any()).Return(nil) + return nil +} + +func (invoker *mockSpanStreamInvoker) CloseAndRecv() error { + invoker.stream.EXPECT().CloseAndRecv().Return(nil) + return nil +} + +func (invoker *mockSpanStreamInvoker) CloseSend() error { + invoker.stream.EXPECT().CloseSend().Return(nil) + return nil +} + +type mockStaGrpcClient struct { + client *MockStatClient + stream *MockStat_SendAgentStatClient +} + +func (statGrpcClient *mockStaGrpcClient) SendAgentStat(ctx context.Context) (pb.Stat_SendAgentStatClient, error) { + //stream := statGrpcClient.client.EXPECT().SendAgentStat(ctx).Return(statGrpcClient.stream, nil) + return statGrpcClient.stream, nil +} + +func newMockStatGrpc(agent Agent, t *testing.T) *statGrpc { + ctrl := gomock.NewController(t) + stream := NewMockStat_SendAgentStatClient(ctrl) + statClient := mockStaGrpcClient{NewMockStatClient(ctrl), stream} + return &statGrpc{nil, &statClient, &mockStatStreamInvoker{stream}, agent} +} + +type mockStatStreamInvoker struct { + stream *MockStat_SendAgentStatClient +} + +func (invoker *mockStatStreamInvoker) Send(span *pb.PStatMessage) error { + invoker.stream.EXPECT().Send(gomock.Any()).Return(nil) + return nil +} + +func (invoker *mockStatStreamInvoker) CloseAndRecv() error { + invoker.stream.EXPECT().CloseAndRecv().Return(nil) + return nil +} + +func (invoker *mockStatStreamInvoker) CloseSend() error { + invoker.stream.EXPECT().CloseSend().Return(nil) + return nil +} diff --git a/mock_grpc.go b/mock_grpc.go new file mode 100644 index 0000000..a8eef55 --- /dev/null +++ b/mock_grpc.go @@ -0,0 +1,2016 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: protobuf/Service.pb.go + +// Package mock_v1 is a generated GoMock package. +package pinpoint + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + empty "github.com/golang/protobuf/ptypes/empty" + v1 "github.com/pinpoint-apm/pinpoint-go-agent/protobuf" + grpc "google.golang.org/grpc" + metadata "google.golang.org/grpc/metadata" +) + +// MockSpanClient is a mock of SpanClient interface. +type MockSpanClient struct { + ctrl *gomock.Controller + recorder *MockSpanClientMockRecorder +} + +// MockSpanClientMockRecorder is the mock recorder for MockSpanClient. +type MockSpanClientMockRecorder struct { + mock *MockSpanClient +} + +// NewMockSpanClient creates a new mock instance. +func NewMockSpanClient(ctrl *gomock.Controller) *MockSpanClient { + mock := &MockSpanClient{ctrl: ctrl} + mock.recorder = &MockSpanClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSpanClient) EXPECT() *MockSpanClientMockRecorder { + return m.recorder +} + +// SendSpan mocks base method. +func (m *MockSpanClient) SendSpan(ctx context.Context, opts ...grpc.CallOption) (v1.Span_SendSpanClient, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SendSpan", varargs...) + ret0, _ := ret[0].(v1.Span_SendSpanClient) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendSpan indicates an expected call of SendSpan. +func (mr *MockSpanClientMockRecorder) SendSpan(ctx interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendSpan", reflect.TypeOf((*MockSpanClient)(nil).SendSpan), varargs...) +} + +// MockSpan_SendSpanClient is a mock of Span_SendSpanClient interface. +type MockSpan_SendSpanClient struct { + ctrl *gomock.Controller + recorder *MockSpan_SendSpanClientMockRecorder +} + +// MockSpan_SendSpanClientMockRecorder is the mock recorder for MockSpan_SendSpanClient. +type MockSpan_SendSpanClientMockRecorder struct { + mock *MockSpan_SendSpanClient +} + +// NewMockSpan_SendSpanClient creates a new mock instance. +func NewMockSpan_SendSpanClient(ctrl *gomock.Controller) *MockSpan_SendSpanClient { + mock := &MockSpan_SendSpanClient{ctrl: ctrl} + mock.recorder = &MockSpan_SendSpanClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSpan_SendSpanClient) EXPECT() *MockSpan_SendSpanClientMockRecorder { + return m.recorder +} + +// CloseAndRecv mocks base method. +func (m *MockSpan_SendSpanClient) CloseAndRecv() (*empty.Empty, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CloseAndRecv") + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CloseAndRecv indicates an expected call of CloseAndRecv. +func (mr *MockSpan_SendSpanClientMockRecorder) CloseAndRecv() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseAndRecv", reflect.TypeOf((*MockSpan_SendSpanClient)(nil).CloseAndRecv)) +} + +// CloseSend mocks base method. +func (m *MockSpan_SendSpanClient) CloseSend() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CloseSend") + ret0, _ := ret[0].(error) + return ret0 +} + +// CloseSend indicates an expected call of CloseSend. +func (mr *MockSpan_SendSpanClientMockRecorder) CloseSend() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockSpan_SendSpanClient)(nil).CloseSend)) +} + +// Context mocks base method. +func (m *MockSpan_SendSpanClient) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockSpan_SendSpanClientMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockSpan_SendSpanClient)(nil).Context)) +} + +// Header mocks base method. +func (m *MockSpan_SendSpanClient) Header() (metadata.MD, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Header") + ret0, _ := ret[0].(metadata.MD) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Header indicates an expected call of Header. +func (mr *MockSpan_SendSpanClientMockRecorder) Header() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockSpan_SendSpanClient)(nil).Header)) +} + +// RecvMsg mocks base method. +func (m_2 *MockSpan_SendSpanClient) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockSpan_SendSpanClientMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockSpan_SendSpanClient)(nil).RecvMsg), m) +} + +// Send mocks base method. +func (m *MockSpan_SendSpanClient) Send(arg0 *v1.PSpanMessage) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Send", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Send indicates an expected call of Send. +func (mr *MockSpan_SendSpanClientMockRecorder) Send(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockSpan_SendSpanClient)(nil).Send), arg0) +} + +// SendMsg mocks base method. +func (m_2 *MockSpan_SendSpanClient) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockSpan_SendSpanClientMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockSpan_SendSpanClient)(nil).SendMsg), m) +} + +// Trailer mocks base method. +func (m *MockSpan_SendSpanClient) Trailer() metadata.MD { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Trailer") + ret0, _ := ret[0].(metadata.MD) + return ret0 +} + +// Trailer indicates an expected call of Trailer. +func (mr *MockSpan_SendSpanClientMockRecorder) Trailer() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockSpan_SendSpanClient)(nil).Trailer)) +} + +// MockSpanServer is a mock of SpanServer interface. +type MockSpanServer struct { + ctrl *gomock.Controller + recorder *MockSpanServerMockRecorder +} + +// MockSpanServerMockRecorder is the mock recorder for MockSpanServer. +type MockSpanServerMockRecorder struct { + mock *MockSpanServer +} + +// NewMockSpanServer creates a new mock instance. +func NewMockSpanServer(ctrl *gomock.Controller) *MockSpanServer { + mock := &MockSpanServer{ctrl: ctrl} + mock.recorder = &MockSpanServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSpanServer) EXPECT() *MockSpanServerMockRecorder { + return m.recorder +} + +// SendSpan mocks base method. +func (m *MockSpanServer) SendSpan(arg0 v1.Span_SendSpanServer) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendSpan", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendSpan indicates an expected call of SendSpan. +func (mr *MockSpanServerMockRecorder) SendSpan(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendSpan", reflect.TypeOf((*MockSpanServer)(nil).SendSpan), arg0) +} + +// MockSpan_SendSpanServer is a mock of Span_SendSpanServer interface. +type MockSpan_SendSpanServer struct { + ctrl *gomock.Controller + recorder *MockSpan_SendSpanServerMockRecorder +} + +// MockSpan_SendSpanServerMockRecorder is the mock recorder for MockSpan_SendSpanServer. +type MockSpan_SendSpanServerMockRecorder struct { + mock *MockSpan_SendSpanServer +} + +// NewMockSpan_SendSpanServer creates a new mock instance. +func NewMockSpan_SendSpanServer(ctrl *gomock.Controller) *MockSpan_SendSpanServer { + mock := &MockSpan_SendSpanServer{ctrl: ctrl} + mock.recorder = &MockSpan_SendSpanServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSpan_SendSpanServer) EXPECT() *MockSpan_SendSpanServerMockRecorder { + return m.recorder +} + +// Context mocks base method. +func (m *MockSpan_SendSpanServer) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockSpan_SendSpanServerMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockSpan_SendSpanServer)(nil).Context)) +} + +// Recv mocks base method. +func (m *MockSpan_SendSpanServer) Recv() (*v1.PSpanMessage, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Recv") + ret0, _ := ret[0].(*v1.PSpanMessage) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Recv indicates an expected call of Recv. +func (mr *MockSpan_SendSpanServerMockRecorder) Recv() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockSpan_SendSpanServer)(nil).Recv)) +} + +// RecvMsg mocks base method. +func (m_2 *MockSpan_SendSpanServer) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockSpan_SendSpanServerMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockSpan_SendSpanServer)(nil).RecvMsg), m) +} + +// SendAndClose mocks base method. +func (m *MockSpan_SendSpanServer) SendAndClose(arg0 *empty.Empty) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendAndClose", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendAndClose indicates an expected call of SendAndClose. +func (mr *MockSpan_SendSpanServerMockRecorder) SendAndClose(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAndClose", reflect.TypeOf((*MockSpan_SendSpanServer)(nil).SendAndClose), arg0) +} + +// SendHeader mocks base method. +func (m *MockSpan_SendSpanServer) SendHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendHeader indicates an expected call of SendHeader. +func (mr *MockSpan_SendSpanServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockSpan_SendSpanServer)(nil).SendHeader), arg0) +} + +// SendMsg mocks base method. +func (m_2 *MockSpan_SendSpanServer) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockSpan_SendSpanServerMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockSpan_SendSpanServer)(nil).SendMsg), m) +} + +// SetHeader mocks base method. +func (m *MockSpan_SendSpanServer) SetHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetHeader indicates an expected call of SetHeader. +func (mr *MockSpan_SendSpanServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockSpan_SendSpanServer)(nil).SetHeader), arg0) +} + +// SetTrailer mocks base method. +func (m *MockSpan_SendSpanServer) SetTrailer(arg0 metadata.MD) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetTrailer", arg0) +} + +// SetTrailer indicates an expected call of SetTrailer. +func (mr *MockSpan_SendSpanServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockSpan_SendSpanServer)(nil).SetTrailer), arg0) +} + +// MockAgentClient is a mock of AgentClient interface. +type MockAgentClient struct { + ctrl *gomock.Controller + recorder *MockAgentClientMockRecorder +} + +// MockAgentClientMockRecorder is the mock recorder for MockAgentClient. +type MockAgentClientMockRecorder struct { + mock *MockAgentClient +} + +// NewMockAgentClient creates a new mock instance. +func NewMockAgentClient(ctrl *gomock.Controller) *MockAgentClient { + mock := &MockAgentClient{ctrl: ctrl} + mock.recorder = &MockAgentClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockAgentClient) EXPECT() *MockAgentClientMockRecorder { + return m.recorder +} + +// PingSession mocks base method. +func (m *MockAgentClient) PingSession(ctx context.Context, opts ...grpc.CallOption) (v1.Agent_PingSessionClient, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PingSession", varargs...) + ret0, _ := ret[0].(v1.Agent_PingSessionClient) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PingSession indicates an expected call of PingSession. +func (mr *MockAgentClientMockRecorder) PingSession(ctx interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PingSession", reflect.TypeOf((*MockAgentClient)(nil).PingSession), varargs...) +} + +// RequestAgentInfo mocks base method. +func (m *MockAgentClient) RequestAgentInfo(ctx context.Context, in *v1.PAgentInfo, opts ...grpc.CallOption) (*v1.PResult, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestAgentInfo", varargs...) + ret0, _ := ret[0].(*v1.PResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestAgentInfo indicates an expected call of RequestAgentInfo. +func (mr *MockAgentClientMockRecorder) RequestAgentInfo(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestAgentInfo", reflect.TypeOf((*MockAgentClient)(nil).RequestAgentInfo), varargs...) +} + +// MockAgent_PingSessionClient is a mock of Agent_PingSessionClient interface. +type MockAgent_PingSessionClient struct { + ctrl *gomock.Controller + recorder *MockAgent_PingSessionClientMockRecorder +} + +// MockAgent_PingSessionClientMockRecorder is the mock recorder for MockAgent_PingSessionClient. +type MockAgent_PingSessionClientMockRecorder struct { + mock *MockAgent_PingSessionClient +} + +// NewMockAgent_PingSessionClient creates a new mock instance. +func NewMockAgent_PingSessionClient(ctrl *gomock.Controller) *MockAgent_PingSessionClient { + mock := &MockAgent_PingSessionClient{ctrl: ctrl} + mock.recorder = &MockAgent_PingSessionClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockAgent_PingSessionClient) EXPECT() *MockAgent_PingSessionClientMockRecorder { + return m.recorder +} + +// CloseSend mocks base method. +func (m *MockAgent_PingSessionClient) CloseSend() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CloseSend") + ret0, _ := ret[0].(error) + return ret0 +} + +// CloseSend indicates an expected call of CloseSend. +func (mr *MockAgent_PingSessionClientMockRecorder) CloseSend() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockAgent_PingSessionClient)(nil).CloseSend)) +} + +// Context mocks base method. +func (m *MockAgent_PingSessionClient) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockAgent_PingSessionClientMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockAgent_PingSessionClient)(nil).Context)) +} + +// Header mocks base method. +func (m *MockAgent_PingSessionClient) Header() (metadata.MD, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Header") + ret0, _ := ret[0].(metadata.MD) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Header indicates an expected call of Header. +func (mr *MockAgent_PingSessionClientMockRecorder) Header() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockAgent_PingSessionClient)(nil).Header)) +} + +// Recv mocks base method. +func (m *MockAgent_PingSessionClient) Recv() (*v1.PPing, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Recv") + ret0, _ := ret[0].(*v1.PPing) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Recv indicates an expected call of Recv. +func (mr *MockAgent_PingSessionClientMockRecorder) Recv() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockAgent_PingSessionClient)(nil).Recv)) +} + +// RecvMsg mocks base method. +func (m_2 *MockAgent_PingSessionClient) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockAgent_PingSessionClientMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockAgent_PingSessionClient)(nil).RecvMsg), m) +} + +// Send mocks base method. +func (m *MockAgent_PingSessionClient) Send(arg0 *v1.PPing) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Send", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Send indicates an expected call of Send. +func (mr *MockAgent_PingSessionClientMockRecorder) Send(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockAgent_PingSessionClient)(nil).Send), arg0) +} + +// SendMsg mocks base method. +func (m_2 *MockAgent_PingSessionClient) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockAgent_PingSessionClientMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockAgent_PingSessionClient)(nil).SendMsg), m) +} + +// Trailer mocks base method. +func (m *MockAgent_PingSessionClient) Trailer() metadata.MD { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Trailer") + ret0, _ := ret[0].(metadata.MD) + return ret0 +} + +// Trailer indicates an expected call of Trailer. +func (mr *MockAgent_PingSessionClientMockRecorder) Trailer() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockAgent_PingSessionClient)(nil).Trailer)) +} + +// MockAgentServer is a mock of AgentServer interface. +type MockAgentServer struct { + ctrl *gomock.Controller + recorder *MockAgentServerMockRecorder +} + +// MockAgentServerMockRecorder is the mock recorder for MockAgentServer. +type MockAgentServerMockRecorder struct { + mock *MockAgentServer +} + +// NewMockAgentServer creates a new mock instance. +func NewMockAgentServer(ctrl *gomock.Controller) *MockAgentServer { + mock := &MockAgentServer{ctrl: ctrl} + mock.recorder = &MockAgentServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockAgentServer) EXPECT() *MockAgentServerMockRecorder { + return m.recorder +} + +// PingSession mocks base method. +func (m *MockAgentServer) PingSession(arg0 v1.Agent_PingSessionServer) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PingSession", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// PingSession indicates an expected call of PingSession. +func (mr *MockAgentServerMockRecorder) PingSession(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PingSession", reflect.TypeOf((*MockAgentServer)(nil).PingSession), arg0) +} + +// RequestAgentInfo mocks base method. +func (m *MockAgentServer) RequestAgentInfo(arg0 context.Context, arg1 *v1.PAgentInfo) (*v1.PResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestAgentInfo", arg0, arg1) + ret0, _ := ret[0].(*v1.PResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestAgentInfo indicates an expected call of RequestAgentInfo. +func (mr *MockAgentServerMockRecorder) RequestAgentInfo(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestAgentInfo", reflect.TypeOf((*MockAgentServer)(nil).RequestAgentInfo), arg0, arg1) +} + +// MockAgent_PingSessionServer is a mock of Agent_PingSessionServer interface. +type MockAgent_PingSessionServer struct { + ctrl *gomock.Controller + recorder *MockAgent_PingSessionServerMockRecorder +} + +// MockAgent_PingSessionServerMockRecorder is the mock recorder for MockAgent_PingSessionServer. +type MockAgent_PingSessionServerMockRecorder struct { + mock *MockAgent_PingSessionServer +} + +// NewMockAgent_PingSessionServer creates a new mock instance. +func NewMockAgent_PingSessionServer(ctrl *gomock.Controller) *MockAgent_PingSessionServer { + mock := &MockAgent_PingSessionServer{ctrl: ctrl} + mock.recorder = &MockAgent_PingSessionServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockAgent_PingSessionServer) EXPECT() *MockAgent_PingSessionServerMockRecorder { + return m.recorder +} + +// Context mocks base method. +func (m *MockAgent_PingSessionServer) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockAgent_PingSessionServerMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockAgent_PingSessionServer)(nil).Context)) +} + +// Recv mocks base method. +func (m *MockAgent_PingSessionServer) Recv() (*v1.PPing, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Recv") + ret0, _ := ret[0].(*v1.PPing) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Recv indicates an expected call of Recv. +func (mr *MockAgent_PingSessionServerMockRecorder) Recv() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockAgent_PingSessionServer)(nil).Recv)) +} + +// RecvMsg mocks base method. +func (m_2 *MockAgent_PingSessionServer) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockAgent_PingSessionServerMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockAgent_PingSessionServer)(nil).RecvMsg), m) +} + +// Send mocks base method. +func (m *MockAgent_PingSessionServer) Send(arg0 *v1.PPing) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Send", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Send indicates an expected call of Send. +func (mr *MockAgent_PingSessionServerMockRecorder) Send(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockAgent_PingSessionServer)(nil).Send), arg0) +} + +// SendHeader mocks base method. +func (m *MockAgent_PingSessionServer) SendHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendHeader indicates an expected call of SendHeader. +func (mr *MockAgent_PingSessionServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockAgent_PingSessionServer)(nil).SendHeader), arg0) +} + +// SendMsg mocks base method. +func (m_2 *MockAgent_PingSessionServer) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockAgent_PingSessionServerMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockAgent_PingSessionServer)(nil).SendMsg), m) +} + +// SetHeader mocks base method. +func (m *MockAgent_PingSessionServer) SetHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetHeader indicates an expected call of SetHeader. +func (mr *MockAgent_PingSessionServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockAgent_PingSessionServer)(nil).SetHeader), arg0) +} + +// SetTrailer mocks base method. +func (m *MockAgent_PingSessionServer) SetTrailer(arg0 metadata.MD) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetTrailer", arg0) +} + +// SetTrailer indicates an expected call of SetTrailer. +func (mr *MockAgent_PingSessionServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockAgent_PingSessionServer)(nil).SetTrailer), arg0) +} + +// MockMetadataClient is a mock of MetadataClient interface. +type MockMetadataClient struct { + ctrl *gomock.Controller + recorder *MockMetadataClientMockRecorder +} + +// MockMetadataClientMockRecorder is the mock recorder for MockMetadataClient. +type MockMetadataClientMockRecorder struct { + mock *MockMetadataClient +} + +// NewMockMetadataClient creates a new mock instance. +func NewMockMetadataClient(ctrl *gomock.Controller) *MockMetadataClient { + mock := &MockMetadataClient{ctrl: ctrl} + mock.recorder = &MockMetadataClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMetadataClient) EXPECT() *MockMetadataClientMockRecorder { + return m.recorder +} + +// RequestApiMetaData mocks base method. +func (m *MockMetadataClient) RequestApiMetaData(ctx context.Context, in *v1.PApiMetaData, opts ...grpc.CallOption) (*v1.PResult, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestApiMetaData", varargs...) + ret0, _ := ret[0].(*v1.PResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestApiMetaData indicates an expected call of RequestApiMetaData. +func (mr *MockMetadataClientMockRecorder) RequestApiMetaData(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestApiMetaData", reflect.TypeOf((*MockMetadataClient)(nil).RequestApiMetaData), varargs...) +} + +// RequestSqlMetaData mocks base method. +func (m *MockMetadataClient) RequestSqlMetaData(ctx context.Context, in *v1.PSqlMetaData, opts ...grpc.CallOption) (*v1.PResult, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestSqlMetaData", varargs...) + ret0, _ := ret[0].(*v1.PResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestSqlMetaData indicates an expected call of RequestSqlMetaData. +func (mr *MockMetadataClientMockRecorder) RequestSqlMetaData(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSqlMetaData", reflect.TypeOf((*MockMetadataClient)(nil).RequestSqlMetaData), varargs...) +} + +// RequestStringMetaData mocks base method. +func (m *MockMetadataClient) RequestStringMetaData(ctx context.Context, in *v1.PStringMetaData, opts ...grpc.CallOption) (*v1.PResult, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestStringMetaData", varargs...) + ret0, _ := ret[0].(*v1.PResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestStringMetaData indicates an expected call of RequestStringMetaData. +func (mr *MockMetadataClientMockRecorder) RequestStringMetaData(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestStringMetaData", reflect.TypeOf((*MockMetadataClient)(nil).RequestStringMetaData), varargs...) +} + +// MockMetadataServer is a mock of MetadataServer interface. +type MockMetadataServer struct { + ctrl *gomock.Controller + recorder *MockMetadataServerMockRecorder +} + +// MockMetadataServerMockRecorder is the mock recorder for MockMetadataServer. +type MockMetadataServerMockRecorder struct { + mock *MockMetadataServer +} + +// NewMockMetadataServer creates a new mock instance. +func NewMockMetadataServer(ctrl *gomock.Controller) *MockMetadataServer { + mock := &MockMetadataServer{ctrl: ctrl} + mock.recorder = &MockMetadataServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMetadataServer) EXPECT() *MockMetadataServerMockRecorder { + return m.recorder +} + +// RequestApiMetaData mocks base method. +func (m *MockMetadataServer) RequestApiMetaData(arg0 context.Context, arg1 *v1.PApiMetaData) (*v1.PResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestApiMetaData", arg0, arg1) + ret0, _ := ret[0].(*v1.PResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestApiMetaData indicates an expected call of RequestApiMetaData. +func (mr *MockMetadataServerMockRecorder) RequestApiMetaData(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestApiMetaData", reflect.TypeOf((*MockMetadataServer)(nil).RequestApiMetaData), arg0, arg1) +} + +// RequestSqlMetaData mocks base method. +func (m *MockMetadataServer) RequestSqlMetaData(arg0 context.Context, arg1 *v1.PSqlMetaData) (*v1.PResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestSqlMetaData", arg0, arg1) + ret0, _ := ret[0].(*v1.PResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestSqlMetaData indicates an expected call of RequestSqlMetaData. +func (mr *MockMetadataServerMockRecorder) RequestSqlMetaData(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSqlMetaData", reflect.TypeOf((*MockMetadataServer)(nil).RequestSqlMetaData), arg0, arg1) +} + +// RequestStringMetaData mocks base method. +func (m *MockMetadataServer) RequestStringMetaData(arg0 context.Context, arg1 *v1.PStringMetaData) (*v1.PResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RequestStringMetaData", arg0, arg1) + ret0, _ := ret[0].(*v1.PResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestStringMetaData indicates an expected call of RequestStringMetaData. +func (mr *MockMetadataServerMockRecorder) RequestStringMetaData(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestStringMetaData", reflect.TypeOf((*MockMetadataServer)(nil).RequestStringMetaData), arg0, arg1) +} + +// MockStatClient is a mock of StatClient interface. +type MockStatClient struct { + ctrl *gomock.Controller + recorder *MockStatClientMockRecorder +} + +// MockStatClientMockRecorder is the mock recorder for MockStatClient. +type MockStatClientMockRecorder struct { + mock *MockStatClient +} + +// NewMockStatClient creates a new mock instance. +func NewMockStatClient(ctrl *gomock.Controller) *MockStatClient { + mock := &MockStatClient{ctrl: ctrl} + mock.recorder = &MockStatClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStatClient) EXPECT() *MockStatClientMockRecorder { + return m.recorder +} + +// SendAgentStat mocks base method. +func (m *MockStatClient) SendAgentStat(ctx context.Context, opts ...grpc.CallOption) (v1.Stat_SendAgentStatClient, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SendAgentStat", varargs...) + ret0, _ := ret[0].(v1.Stat_SendAgentStatClient) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendAgentStat indicates an expected call of SendAgentStat. +func (mr *MockStatClientMockRecorder) SendAgentStat(ctx interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAgentStat", reflect.TypeOf((*MockStatClient)(nil).SendAgentStat), varargs...) +} + +// MockStat_SendAgentStatClient is a mock of Stat_SendAgentStatClient interface. +type MockStat_SendAgentStatClient struct { + ctrl *gomock.Controller + recorder *MockStat_SendAgentStatClientMockRecorder +} + +// MockStat_SendAgentStatClientMockRecorder is the mock recorder for MockStat_SendAgentStatClient. +type MockStat_SendAgentStatClientMockRecorder struct { + mock *MockStat_SendAgentStatClient +} + +// NewMockStat_SendAgentStatClient creates a new mock instance. +func NewMockStat_SendAgentStatClient(ctrl *gomock.Controller) *MockStat_SendAgentStatClient { + mock := &MockStat_SendAgentStatClient{ctrl: ctrl} + mock.recorder = &MockStat_SendAgentStatClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStat_SendAgentStatClient) EXPECT() *MockStat_SendAgentStatClientMockRecorder { + return m.recorder +} + +// CloseAndRecv mocks base method. +func (m *MockStat_SendAgentStatClient) CloseAndRecv() (*empty.Empty, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CloseAndRecv") + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CloseAndRecv indicates an expected call of CloseAndRecv. +func (mr *MockStat_SendAgentStatClientMockRecorder) CloseAndRecv() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseAndRecv", reflect.TypeOf((*MockStat_SendAgentStatClient)(nil).CloseAndRecv)) +} + +// CloseSend mocks base method. +func (m *MockStat_SendAgentStatClient) CloseSend() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CloseSend") + ret0, _ := ret[0].(error) + return ret0 +} + +// CloseSend indicates an expected call of CloseSend. +func (mr *MockStat_SendAgentStatClientMockRecorder) CloseSend() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockStat_SendAgentStatClient)(nil).CloseSend)) +} + +// Context mocks base method. +func (m *MockStat_SendAgentStatClient) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockStat_SendAgentStatClientMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockStat_SendAgentStatClient)(nil).Context)) +} + +// Header mocks base method. +func (m *MockStat_SendAgentStatClient) Header() (metadata.MD, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Header") + ret0, _ := ret[0].(metadata.MD) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Header indicates an expected call of Header. +func (mr *MockStat_SendAgentStatClientMockRecorder) Header() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockStat_SendAgentStatClient)(nil).Header)) +} + +// RecvMsg mocks base method. +func (m_2 *MockStat_SendAgentStatClient) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockStat_SendAgentStatClientMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockStat_SendAgentStatClient)(nil).RecvMsg), m) +} + +// Send mocks base method. +func (m *MockStat_SendAgentStatClient) Send(arg0 *v1.PStatMessage) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Send", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Send indicates an expected call of Send. +func (mr *MockStat_SendAgentStatClientMockRecorder) Send(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockStat_SendAgentStatClient)(nil).Send), arg0) +} + +// SendMsg mocks base method. +func (m_2 *MockStat_SendAgentStatClient) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockStat_SendAgentStatClientMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockStat_SendAgentStatClient)(nil).SendMsg), m) +} + +// Trailer mocks base method. +func (m *MockStat_SendAgentStatClient) Trailer() metadata.MD { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Trailer") + ret0, _ := ret[0].(metadata.MD) + return ret0 +} + +// Trailer indicates an expected call of Trailer. +func (mr *MockStat_SendAgentStatClientMockRecorder) Trailer() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockStat_SendAgentStatClient)(nil).Trailer)) +} + +// MockStatServer is a mock of StatServer interface. +type MockStatServer struct { + ctrl *gomock.Controller + recorder *MockStatServerMockRecorder +} + +// MockStatServerMockRecorder is the mock recorder for MockStatServer. +type MockStatServerMockRecorder struct { + mock *MockStatServer +} + +// NewMockStatServer creates a new mock instance. +func NewMockStatServer(ctrl *gomock.Controller) *MockStatServer { + mock := &MockStatServer{ctrl: ctrl} + mock.recorder = &MockStatServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStatServer) EXPECT() *MockStatServerMockRecorder { + return m.recorder +} + +// SendAgentStat mocks base method. +func (m *MockStatServer) SendAgentStat(arg0 v1.Stat_SendAgentStatServer) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendAgentStat", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendAgentStat indicates an expected call of SendAgentStat. +func (mr *MockStatServerMockRecorder) SendAgentStat(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAgentStat", reflect.TypeOf((*MockStatServer)(nil).SendAgentStat), arg0) +} + +// MockStat_SendAgentStatServer is a mock of Stat_SendAgentStatServer interface. +type MockStat_SendAgentStatServer struct { + ctrl *gomock.Controller + recorder *MockStat_SendAgentStatServerMockRecorder +} + +// MockStat_SendAgentStatServerMockRecorder is the mock recorder for MockStat_SendAgentStatServer. +type MockStat_SendAgentStatServerMockRecorder struct { + mock *MockStat_SendAgentStatServer +} + +// NewMockStat_SendAgentStatServer creates a new mock instance. +func NewMockStat_SendAgentStatServer(ctrl *gomock.Controller) *MockStat_SendAgentStatServer { + mock := &MockStat_SendAgentStatServer{ctrl: ctrl} + mock.recorder = &MockStat_SendAgentStatServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStat_SendAgentStatServer) EXPECT() *MockStat_SendAgentStatServerMockRecorder { + return m.recorder +} + +// Context mocks base method. +func (m *MockStat_SendAgentStatServer) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockStat_SendAgentStatServerMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockStat_SendAgentStatServer)(nil).Context)) +} + +// Recv mocks base method. +func (m *MockStat_SendAgentStatServer) Recv() (*v1.PStatMessage, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Recv") + ret0, _ := ret[0].(*v1.PStatMessage) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Recv indicates an expected call of Recv. +func (mr *MockStat_SendAgentStatServerMockRecorder) Recv() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockStat_SendAgentStatServer)(nil).Recv)) +} + +// RecvMsg mocks base method. +func (m_2 *MockStat_SendAgentStatServer) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockStat_SendAgentStatServerMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockStat_SendAgentStatServer)(nil).RecvMsg), m) +} + +// SendAndClose mocks base method. +func (m *MockStat_SendAgentStatServer) SendAndClose(arg0 *empty.Empty) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendAndClose", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendAndClose indicates an expected call of SendAndClose. +func (mr *MockStat_SendAgentStatServerMockRecorder) SendAndClose(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAndClose", reflect.TypeOf((*MockStat_SendAgentStatServer)(nil).SendAndClose), arg0) +} + +// SendHeader mocks base method. +func (m *MockStat_SendAgentStatServer) SendHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendHeader indicates an expected call of SendHeader. +func (mr *MockStat_SendAgentStatServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockStat_SendAgentStatServer)(nil).SendHeader), arg0) +} + +// SendMsg mocks base method. +func (m_2 *MockStat_SendAgentStatServer) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockStat_SendAgentStatServerMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockStat_SendAgentStatServer)(nil).SendMsg), m) +} + +// SetHeader mocks base method. +func (m *MockStat_SendAgentStatServer) SetHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetHeader indicates an expected call of SetHeader. +func (mr *MockStat_SendAgentStatServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockStat_SendAgentStatServer)(nil).SetHeader), arg0) +} + +// SetTrailer mocks base method. +func (m *MockStat_SendAgentStatServer) SetTrailer(arg0 metadata.MD) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetTrailer", arg0) +} + +// SetTrailer indicates an expected call of SetTrailer. +func (mr *MockStat_SendAgentStatServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockStat_SendAgentStatServer)(nil).SetTrailer), arg0) +} + +// MockProfilerCommandServiceClient is a mock of ProfilerCommandServiceClient interface. +type MockProfilerCommandServiceClient struct { + ctrl *gomock.Controller + recorder *MockProfilerCommandServiceClientMockRecorder +} + +// MockProfilerCommandServiceClientMockRecorder is the mock recorder for MockProfilerCommandServiceClient. +type MockProfilerCommandServiceClientMockRecorder struct { + mock *MockProfilerCommandServiceClient +} + +// NewMockProfilerCommandServiceClient creates a new mock instance. +func NewMockProfilerCommandServiceClient(ctrl *gomock.Controller) *MockProfilerCommandServiceClient { + mock := &MockProfilerCommandServiceClient{ctrl: ctrl} + mock.recorder = &MockProfilerCommandServiceClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockProfilerCommandServiceClient) EXPECT() *MockProfilerCommandServiceClientMockRecorder { + return m.recorder +} + +// CommandActiveThreadDump mocks base method. +func (m *MockProfilerCommandServiceClient) CommandActiveThreadDump(ctx context.Context, in *v1.PCmdActiveThreadDumpRes, opts ...grpc.CallOption) (*empty.Empty, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandActiveThreadDump", varargs...) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CommandActiveThreadDump indicates an expected call of CommandActiveThreadDump. +func (mr *MockProfilerCommandServiceClientMockRecorder) CommandActiveThreadDump(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandActiveThreadDump", reflect.TypeOf((*MockProfilerCommandServiceClient)(nil).CommandActiveThreadDump), varargs...) +} + +// CommandActiveThreadLightDump mocks base method. +func (m *MockProfilerCommandServiceClient) CommandActiveThreadLightDump(ctx context.Context, in *v1.PCmdActiveThreadLightDumpRes, opts ...grpc.CallOption) (*empty.Empty, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandActiveThreadLightDump", varargs...) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CommandActiveThreadLightDump indicates an expected call of CommandActiveThreadLightDump. +func (mr *MockProfilerCommandServiceClientMockRecorder) CommandActiveThreadLightDump(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandActiveThreadLightDump", reflect.TypeOf((*MockProfilerCommandServiceClient)(nil).CommandActiveThreadLightDump), varargs...) +} + +// CommandEcho mocks base method. +func (m *MockProfilerCommandServiceClient) CommandEcho(ctx context.Context, in *v1.PCmdEchoResponse, opts ...grpc.CallOption) (*empty.Empty, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandEcho", varargs...) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CommandEcho indicates an expected call of CommandEcho. +func (mr *MockProfilerCommandServiceClientMockRecorder) CommandEcho(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandEcho", reflect.TypeOf((*MockProfilerCommandServiceClient)(nil).CommandEcho), varargs...) +} + +// CommandStreamActiveThreadCount mocks base method. +func (m *MockProfilerCommandServiceClient) CommandStreamActiveThreadCount(ctx context.Context, opts ...grpc.CallOption) (v1.ProfilerCommandService_CommandStreamActiveThreadCountClient, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandStreamActiveThreadCount", varargs...) + ret0, _ := ret[0].(v1.ProfilerCommandService_CommandStreamActiveThreadCountClient) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CommandStreamActiveThreadCount indicates an expected call of CommandStreamActiveThreadCount. +func (mr *MockProfilerCommandServiceClientMockRecorder) CommandStreamActiveThreadCount(ctx interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandStreamActiveThreadCount", reflect.TypeOf((*MockProfilerCommandServiceClient)(nil).CommandStreamActiveThreadCount), varargs...) +} + +// HandleCommand mocks base method. +func (m *MockProfilerCommandServiceClient) HandleCommand(ctx context.Context, opts ...grpc.CallOption) (v1.ProfilerCommandService_HandleCommandClient, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HandleCommand", varargs...) + ret0, _ := ret[0].(v1.ProfilerCommandService_HandleCommandClient) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// HandleCommand indicates an expected call of HandleCommand. +func (mr *MockProfilerCommandServiceClientMockRecorder) HandleCommand(ctx interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCommand", reflect.TypeOf((*MockProfilerCommandServiceClient)(nil).HandleCommand), varargs...) +} + +// MockProfilerCommandService_HandleCommandClient is a mock of ProfilerCommandService_HandleCommandClient interface. +type MockProfilerCommandService_HandleCommandClient struct { + ctrl *gomock.Controller + recorder *MockProfilerCommandService_HandleCommandClientMockRecorder +} + +// MockProfilerCommandService_HandleCommandClientMockRecorder is the mock recorder for MockProfilerCommandService_HandleCommandClient. +type MockProfilerCommandService_HandleCommandClientMockRecorder struct { + mock *MockProfilerCommandService_HandleCommandClient +} + +// NewMockProfilerCommandService_HandleCommandClient creates a new mock instance. +func NewMockProfilerCommandService_HandleCommandClient(ctrl *gomock.Controller) *MockProfilerCommandService_HandleCommandClient { + mock := &MockProfilerCommandService_HandleCommandClient{ctrl: ctrl} + mock.recorder = &MockProfilerCommandService_HandleCommandClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockProfilerCommandService_HandleCommandClient) EXPECT() *MockProfilerCommandService_HandleCommandClientMockRecorder { + return m.recorder +} + +// CloseSend mocks base method. +func (m *MockProfilerCommandService_HandleCommandClient) CloseSend() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CloseSend") + ret0, _ := ret[0].(error) + return ret0 +} + +// CloseSend indicates an expected call of CloseSend. +func (mr *MockProfilerCommandService_HandleCommandClientMockRecorder) CloseSend() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProfilerCommandService_HandleCommandClient)(nil).CloseSend)) +} + +// Context mocks base method. +func (m *MockProfilerCommandService_HandleCommandClient) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockProfilerCommandService_HandleCommandClientMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProfilerCommandService_HandleCommandClient)(nil).Context)) +} + +// Header mocks base method. +func (m *MockProfilerCommandService_HandleCommandClient) Header() (metadata.MD, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Header") + ret0, _ := ret[0].(metadata.MD) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Header indicates an expected call of Header. +func (mr *MockProfilerCommandService_HandleCommandClientMockRecorder) Header() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProfilerCommandService_HandleCommandClient)(nil).Header)) +} + +// Recv mocks base method. +func (m *MockProfilerCommandService_HandleCommandClient) Recv() (*v1.PCmdRequest, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Recv") + ret0, _ := ret[0].(*v1.PCmdRequest) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Recv indicates an expected call of Recv. +func (mr *MockProfilerCommandService_HandleCommandClientMockRecorder) Recv() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProfilerCommandService_HandleCommandClient)(nil).Recv)) +} + +// RecvMsg mocks base method. +func (m_2 *MockProfilerCommandService_HandleCommandClient) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockProfilerCommandService_HandleCommandClientMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProfilerCommandService_HandleCommandClient)(nil).RecvMsg), m) +} + +// Send mocks base method. +func (m *MockProfilerCommandService_HandleCommandClient) Send(arg0 *v1.PCmdMessage) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Send", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Send indicates an expected call of Send. +func (mr *MockProfilerCommandService_HandleCommandClientMockRecorder) Send(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockProfilerCommandService_HandleCommandClient)(nil).Send), arg0) +} + +// SendMsg mocks base method. +func (m_2 *MockProfilerCommandService_HandleCommandClient) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockProfilerCommandService_HandleCommandClientMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProfilerCommandService_HandleCommandClient)(nil).SendMsg), m) +} + +// Trailer mocks base method. +func (m *MockProfilerCommandService_HandleCommandClient) Trailer() metadata.MD { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Trailer") + ret0, _ := ret[0].(metadata.MD) + return ret0 +} + +// Trailer indicates an expected call of Trailer. +func (mr *MockProfilerCommandService_HandleCommandClientMockRecorder) Trailer() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProfilerCommandService_HandleCommandClient)(nil).Trailer)) +} + +// MockProfilerCommandService_CommandStreamActiveThreadCountClient is a mock of ProfilerCommandService_CommandStreamActiveThreadCountClient interface. +type MockProfilerCommandService_CommandStreamActiveThreadCountClient struct { + ctrl *gomock.Controller + recorder *MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder +} + +// MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder is the mock recorder for MockProfilerCommandService_CommandStreamActiveThreadCountClient. +type MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder struct { + mock *MockProfilerCommandService_CommandStreamActiveThreadCountClient +} + +// NewMockProfilerCommandService_CommandStreamActiveThreadCountClient creates a new mock instance. +func NewMockProfilerCommandService_CommandStreamActiveThreadCountClient(ctrl *gomock.Controller) *MockProfilerCommandService_CommandStreamActiveThreadCountClient { + mock := &MockProfilerCommandService_CommandStreamActiveThreadCountClient{ctrl: ctrl} + mock.recorder = &MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountClient) EXPECT() *MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder { + return m.recorder +} + +// CloseAndRecv mocks base method. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountClient) CloseAndRecv() (*empty.Empty, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CloseAndRecv") + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CloseAndRecv indicates an expected call of CloseAndRecv. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder) CloseAndRecv() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseAndRecv", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountClient)(nil).CloseAndRecv)) +} + +// CloseSend mocks base method. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountClient) CloseSend() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CloseSend") + ret0, _ := ret[0].(error) + return ret0 +} + +// CloseSend indicates an expected call of CloseSend. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder) CloseSend() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountClient)(nil).CloseSend)) +} + +// Context mocks base method. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountClient) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountClient)(nil).Context)) +} + +// Header mocks base method. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountClient) Header() (metadata.MD, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Header") + ret0, _ := ret[0].(metadata.MD) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Header indicates an expected call of Header. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder) Header() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountClient)(nil).Header)) +} + +// RecvMsg mocks base method. +func (m_2 *MockProfilerCommandService_CommandStreamActiveThreadCountClient) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountClient)(nil).RecvMsg), m) +} + +// Send mocks base method. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountClient) Send(arg0 *v1.PCmdActiveThreadCountRes) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Send", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Send indicates an expected call of Send. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder) Send(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountClient)(nil).Send), arg0) +} + +// SendMsg mocks base method. +func (m_2 *MockProfilerCommandService_CommandStreamActiveThreadCountClient) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountClient)(nil).SendMsg), m) +} + +// Trailer mocks base method. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountClient) Trailer() metadata.MD { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Trailer") + ret0, _ := ret[0].(metadata.MD) + return ret0 +} + +// Trailer indicates an expected call of Trailer. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountClientMockRecorder) Trailer() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountClient)(nil).Trailer)) +} + +// MockProfilerCommandServiceServer is a mock of ProfilerCommandServiceServer interface. +type MockProfilerCommandServiceServer struct { + ctrl *gomock.Controller + recorder *MockProfilerCommandServiceServerMockRecorder +} + +// MockProfilerCommandServiceServerMockRecorder is the mock recorder for MockProfilerCommandServiceServer. +type MockProfilerCommandServiceServerMockRecorder struct { + mock *MockProfilerCommandServiceServer +} + +// NewMockProfilerCommandServiceServer creates a new mock instance. +func NewMockProfilerCommandServiceServer(ctrl *gomock.Controller) *MockProfilerCommandServiceServer { + mock := &MockProfilerCommandServiceServer{ctrl: ctrl} + mock.recorder = &MockProfilerCommandServiceServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockProfilerCommandServiceServer) EXPECT() *MockProfilerCommandServiceServerMockRecorder { + return m.recorder +} + +// CommandActiveThreadDump mocks base method. +func (m *MockProfilerCommandServiceServer) CommandActiveThreadDump(arg0 context.Context, arg1 *v1.PCmdActiveThreadDumpRes) (*empty.Empty, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CommandActiveThreadDump", arg0, arg1) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CommandActiveThreadDump indicates an expected call of CommandActiveThreadDump. +func (mr *MockProfilerCommandServiceServerMockRecorder) CommandActiveThreadDump(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandActiveThreadDump", reflect.TypeOf((*MockProfilerCommandServiceServer)(nil).CommandActiveThreadDump), arg0, arg1) +} + +// CommandActiveThreadLightDump mocks base method. +func (m *MockProfilerCommandServiceServer) CommandActiveThreadLightDump(arg0 context.Context, arg1 *v1.PCmdActiveThreadLightDumpRes) (*empty.Empty, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CommandActiveThreadLightDump", arg0, arg1) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CommandActiveThreadLightDump indicates an expected call of CommandActiveThreadLightDump. +func (mr *MockProfilerCommandServiceServerMockRecorder) CommandActiveThreadLightDump(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandActiveThreadLightDump", reflect.TypeOf((*MockProfilerCommandServiceServer)(nil).CommandActiveThreadLightDump), arg0, arg1) +} + +// CommandEcho mocks base method. +func (m *MockProfilerCommandServiceServer) CommandEcho(arg0 context.Context, arg1 *v1.PCmdEchoResponse) (*empty.Empty, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CommandEcho", arg0, arg1) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CommandEcho indicates an expected call of CommandEcho. +func (mr *MockProfilerCommandServiceServerMockRecorder) CommandEcho(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandEcho", reflect.TypeOf((*MockProfilerCommandServiceServer)(nil).CommandEcho), arg0, arg1) +} + +// CommandStreamActiveThreadCount mocks base method. +func (m *MockProfilerCommandServiceServer) CommandStreamActiveThreadCount(arg0 v1.ProfilerCommandService_CommandStreamActiveThreadCountServer) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CommandStreamActiveThreadCount", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// CommandStreamActiveThreadCount indicates an expected call of CommandStreamActiveThreadCount. +func (mr *MockProfilerCommandServiceServerMockRecorder) CommandStreamActiveThreadCount(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandStreamActiveThreadCount", reflect.TypeOf((*MockProfilerCommandServiceServer)(nil).CommandStreamActiveThreadCount), arg0) +} + +// HandleCommand mocks base method. +func (m *MockProfilerCommandServiceServer) HandleCommand(arg0 v1.ProfilerCommandService_HandleCommandServer) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HandleCommand", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// HandleCommand indicates an expected call of HandleCommand. +func (mr *MockProfilerCommandServiceServerMockRecorder) HandleCommand(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCommand", reflect.TypeOf((*MockProfilerCommandServiceServer)(nil).HandleCommand), arg0) +} + +// MockProfilerCommandService_HandleCommandServer is a mock of ProfilerCommandService_HandleCommandServer interface. +type MockProfilerCommandService_HandleCommandServer struct { + ctrl *gomock.Controller + recorder *MockProfilerCommandService_HandleCommandServerMockRecorder +} + +// MockProfilerCommandService_HandleCommandServerMockRecorder is the mock recorder for MockProfilerCommandService_HandleCommandServer. +type MockProfilerCommandService_HandleCommandServerMockRecorder struct { + mock *MockProfilerCommandService_HandleCommandServer +} + +// NewMockProfilerCommandService_HandleCommandServer creates a new mock instance. +func NewMockProfilerCommandService_HandleCommandServer(ctrl *gomock.Controller) *MockProfilerCommandService_HandleCommandServer { + mock := &MockProfilerCommandService_HandleCommandServer{ctrl: ctrl} + mock.recorder = &MockProfilerCommandService_HandleCommandServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockProfilerCommandService_HandleCommandServer) EXPECT() *MockProfilerCommandService_HandleCommandServerMockRecorder { + return m.recorder +} + +// Context mocks base method. +func (m *MockProfilerCommandService_HandleCommandServer) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockProfilerCommandService_HandleCommandServerMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProfilerCommandService_HandleCommandServer)(nil).Context)) +} + +// Recv mocks base method. +func (m *MockProfilerCommandService_HandleCommandServer) Recv() (*v1.PCmdMessage, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Recv") + ret0, _ := ret[0].(*v1.PCmdMessage) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Recv indicates an expected call of Recv. +func (mr *MockProfilerCommandService_HandleCommandServerMockRecorder) Recv() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProfilerCommandService_HandleCommandServer)(nil).Recv)) +} + +// RecvMsg mocks base method. +func (m_2 *MockProfilerCommandService_HandleCommandServer) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockProfilerCommandService_HandleCommandServerMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProfilerCommandService_HandleCommandServer)(nil).RecvMsg), m) +} + +// Send mocks base method. +func (m *MockProfilerCommandService_HandleCommandServer) Send(arg0 *v1.PCmdRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Send", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Send indicates an expected call of Send. +func (mr *MockProfilerCommandService_HandleCommandServerMockRecorder) Send(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockProfilerCommandService_HandleCommandServer)(nil).Send), arg0) +} + +// SendHeader mocks base method. +func (m *MockProfilerCommandService_HandleCommandServer) SendHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendHeader indicates an expected call of SendHeader. +func (mr *MockProfilerCommandService_HandleCommandServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockProfilerCommandService_HandleCommandServer)(nil).SendHeader), arg0) +} + +// SendMsg mocks base method. +func (m_2 *MockProfilerCommandService_HandleCommandServer) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockProfilerCommandService_HandleCommandServerMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProfilerCommandService_HandleCommandServer)(nil).SendMsg), m) +} + +// SetHeader mocks base method. +func (m *MockProfilerCommandService_HandleCommandServer) SetHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetHeader indicates an expected call of SetHeader. +func (mr *MockProfilerCommandService_HandleCommandServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockProfilerCommandService_HandleCommandServer)(nil).SetHeader), arg0) +} + +// SetTrailer mocks base method. +func (m *MockProfilerCommandService_HandleCommandServer) SetTrailer(arg0 metadata.MD) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetTrailer", arg0) +} + +// SetTrailer indicates an expected call of SetTrailer. +func (mr *MockProfilerCommandService_HandleCommandServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockProfilerCommandService_HandleCommandServer)(nil).SetTrailer), arg0) +} + +// MockProfilerCommandService_CommandStreamActiveThreadCountServer is a mock of ProfilerCommandService_CommandStreamActiveThreadCountServer interface. +type MockProfilerCommandService_CommandStreamActiveThreadCountServer struct { + ctrl *gomock.Controller + recorder *MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder +} + +// MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder is the mock recorder for MockProfilerCommandService_CommandStreamActiveThreadCountServer. +type MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder struct { + mock *MockProfilerCommandService_CommandStreamActiveThreadCountServer +} + +// NewMockProfilerCommandService_CommandStreamActiveThreadCountServer creates a new mock instance. +func NewMockProfilerCommandService_CommandStreamActiveThreadCountServer(ctrl *gomock.Controller) *MockProfilerCommandService_CommandStreamActiveThreadCountServer { + mock := &MockProfilerCommandService_CommandStreamActiveThreadCountServer{ctrl: ctrl} + mock.recorder = &MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountServer) EXPECT() *MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder { + return m.recorder +} + +// Context mocks base method. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountServer) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountServer)(nil).Context)) +} + +// Recv mocks base method. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountServer) Recv() (*v1.PCmdActiveThreadCountRes, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Recv") + ret0, _ := ret[0].(*v1.PCmdActiveThreadCountRes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Recv indicates an expected call of Recv. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder) Recv() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountServer)(nil).Recv)) +} + +// RecvMsg mocks base method. +func (m_2 *MockProfilerCommandService_CommandStreamActiveThreadCountServer) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountServer)(nil).RecvMsg), m) +} + +// SendAndClose mocks base method. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountServer) SendAndClose(arg0 *empty.Empty) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendAndClose", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendAndClose indicates an expected call of SendAndClose. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder) SendAndClose(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAndClose", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountServer)(nil).SendAndClose), arg0) +} + +// SendHeader mocks base method. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountServer) SendHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendHeader indicates an expected call of SendHeader. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountServer)(nil).SendHeader), arg0) +} + +// SendMsg mocks base method. +func (m_2 *MockProfilerCommandService_CommandStreamActiveThreadCountServer) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountServer)(nil).SendMsg), m) +} + +// SetHeader mocks base method. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountServer) SetHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetHeader indicates an expected call of SetHeader. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountServer)(nil).SetHeader), arg0) +} + +// SetTrailer mocks base method. +func (m *MockProfilerCommandService_CommandStreamActiveThreadCountServer) SetTrailer(arg0 metadata.MD) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetTrailer", arg0) +} + +// SetTrailer indicates an expected call of SetTrailer. +func (mr *MockProfilerCommandService_CommandStreamActiveThreadCountServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockProfilerCommandService_CommandStreamActiveThreadCountServer)(nil).SetTrailer), arg0) +} diff --git a/noop.go b/noop.go index 9fc9af2..8a52749 100644 --- a/noop.go +++ b/noop.go @@ -5,12 +5,12 @@ import ( ) type noopSpan struct { - agent *Agent + agent Agent noopSe noopSpanEvent annotations noopannotation } -func newNoopSpan(agent *Agent) Tracer { +func newNoopSpan(agent Agent) Tracer { span := noopSpan{} span.agent = agent return &span @@ -31,7 +31,7 @@ func (span *noopSpan) NewAsyncSpan() Tracer { func (span *noopSpan) EndSpanEvent() {} func (span *noopSpan) TransactionId() TransactionId { - return TransactionId{span.agent.config.AgentId, span.agent.startTime, -1} + return TransactionId{span.agent.Config().AgentId, span.agent.StartTime(), -1} } func (span *noopSpan) SpanId() int64 { diff --git a/plugin/chi/chi.go b/plugin/chi/chi.go index 86a7ed0..bafe0c7 100644 --- a/plugin/chi/chi.go +++ b/plugin/chi/chi.go @@ -7,8 +7,8 @@ import ( phttp "github.com/pinpoint-apm/pinpoint-go-agent/plugin/http" ) -func Middleware(agent *pinpoint.Agent) func(http.Handler) http.Handler { - if agent == nil { +func Middleware(agent pinpoint.Agent) func(http.Handler) http.Handler { + if !agent.Enable() { return func(next http.Handler) http.Handler { return next } diff --git a/plugin/chi/example/chi_server.go b/plugin/chi/example/chi_server.go index aa12617..8bce8d5 100644 --- a/plugin/chi/example/chi_server.go +++ b/plugin/chi/example/chi_server.go @@ -13,7 +13,7 @@ import ( phttp "github.com/pinpoint-apm/pinpoint-go-agent/plugin/http" ) -var agent *pinpoint.Agent +var agent pinpoint.Agent func hello(w http.ResponseWriter, r *http.Request) { io.WriteString(w, "hello world") diff --git a/plugin/echo/echo.go b/plugin/echo/echo.go index e1b38d2..570ddeb 100644 --- a/plugin/echo/echo.go +++ b/plugin/echo/echo.go @@ -7,8 +7,8 @@ import ( phttp "github.com/pinpoint-apm/pinpoint-go-agent/plugin/http" ) -func Middleware(agent *pinpoint.Agent) echo.MiddlewareFunc { - if agent == nil { +func Middleware(agent pinpoint.Agent) echo.MiddlewareFunc { + if !agent.Enable() { return func(next echo.HandlerFunc) echo.HandlerFunc { return next } diff --git a/plugin/gin/gin.go b/plugin/gin/gin.go index 8e144eb..8672aa4 100644 --- a/plugin/gin/gin.go +++ b/plugin/gin/gin.go @@ -6,11 +6,11 @@ import ( phttp "github.com/pinpoint-apm/pinpoint-go-agent/plugin/http" ) -func Middleware(agent *pinpoint.Agent) gin.HandlerFunc { +func Middleware(agent pinpoint.Agent) gin.HandlerFunc { apiId := agent.RegisterSpanApiId("Go Gin Server", pinpoint.ApiTypeWebRequest) return func(c *gin.Context) { - if agent != nil { + if agent.Enable() { tracer := phttp.NewHttpServerTracer(agent, c.Request, "Gin Server") defer tracer.EndSpan() tracer.Span().SetApiId(apiId) diff --git a/plugin/grpc/server.go b/plugin/grpc/server.go index 5c22de3..8665518 100644 --- a/plugin/grpc/server.go +++ b/plugin/grpc/server.go @@ -31,7 +31,7 @@ func (m DistributedTracingContextReaderMD) Get(key string) string { return v[0] } -func startSpan(ctx context.Context, agent *pinpoint.Agent, apiId int32, rpcName string) pinpoint.Tracer { +func startSpan(ctx context.Context, agent pinpoint.Agent, apiId int32, rpcName string) pinpoint.Tracer { md, _ := metadata.FromIncomingContext(ctx) // nil is ok reader := &DistributedTracingContextReaderMD{md} tracer := agent.NewSpanTracerWithReader("Go GRPC Server", reader) @@ -42,11 +42,11 @@ func startSpan(ctx context.Context, agent *pinpoint.Agent, apiId int32, rpcName return tracer } -func UnaryServerInterceptor(agent *pinpoint.Agent) grpc.UnaryServerInterceptor { +func UnaryServerInterceptor(agent pinpoint.Agent) grpc.UnaryServerInterceptor { apiId := agent.RegisterSpanApiId("Go gRPC HTTP Server", pinpoint.ApiTypeWebRequest) return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) { - if agent == nil { + if !agent.Enable() { return handler(ctx, req) } @@ -63,11 +63,11 @@ func UnaryServerInterceptor(agent *pinpoint.Agent) grpc.UnaryServerInterceptor { } } -func StreamServerInterceptor(agent *pinpoint.Agent) grpc.StreamServerInterceptor { +func StreamServerInterceptor(agent pinpoint.Agent) grpc.StreamServerInterceptor { apiId := agent.RegisterSpanApiId("Go gRPC HTTP Server", pinpoint.ApiTypeWebRequest) return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error { - if agent == nil { + if !agent.Enable() { return handler(srv, stream) } diff --git a/plugin/http/server.go b/plugin/http/server.go index 666555a..3a84ddf 100644 --- a/plugin/http/server.go +++ b/plugin/http/server.go @@ -11,7 +11,7 @@ import ( const AnnotationProxyHttpHeader = 300 -func NewHttpServerTracer(agent *pinpoint.Agent, req *http.Request, operation string) pinpoint.Tracer { +func NewHttpServerTracer(agent pinpoint.Agent, req *http.Request, operation string) pinpoint.Tracer { tracer := agent.NewSpanTracerWithReader(operation, req.Header) tracer.Span().SetRpcName(req.URL.Path) @@ -103,8 +103,8 @@ func TraceHttpStatus(tracer pinpoint.Tracer, status int) { } } -func WrapHandle(agent *pinpoint.Agent, handlerName string, pattern string, handler http.Handler) (string, http.Handler) { - if agent == nil { +func WrapHandle(agent pinpoint.Agent, handlerName string, pattern string, handler http.Handler) (string, http.Handler) { + if !agent.Enable() { return pattern, handler } @@ -125,7 +125,7 @@ func WrapHandle(agent *pinpoint.Agent, handlerName string, pattern string, handl }) } -func WrapHandleFunc(agent *pinpoint.Agent, handlerName string, pattern string, handler func(http.ResponseWriter, *http.Request)) (string, func(http.ResponseWriter, *http.Request)) { +func WrapHandleFunc(agent pinpoint.Agent, handlerName string, pattern string, handler func(http.ResponseWriter, *http.Request)) (string, func(http.ResponseWriter, *http.Request)) { p, h := WrapHandle(agent, handlerName, pattern, http.HandlerFunc(handler)) return p, func(w http.ResponseWriter, r *http.Request) { h.ServeHTTP(w, r) } } diff --git a/plugin/sarama/consumer.go b/plugin/sarama/consumer.go index 9de8598..697e15c 100644 --- a/plugin/sarama/consumer.go +++ b/plugin/sarama/consumer.go @@ -46,7 +46,7 @@ func (m *DistributedTracingContextReaderConsumer) Get(key string) string { return "" } -func WrapPartitionConsumer(pc sarama.PartitionConsumer, agent *pinpoint.Agent) *PartitionConsumer { +func WrapPartitionConsumer(pc sarama.PartitionConsumer, agent pinpoint.Agent) *PartitionConsumer { wrapped := &PartitionConsumer{ PartitionConsumer: pc, messages: make(chan *ConsumerMessage), @@ -91,7 +91,7 @@ func makeRpcName(msg *sarama.ConsumerMessage) string { type Consumer struct { sarama.Consumer - agent *pinpoint.Agent + agent pinpoint.Agent } func (c *Consumer) ConsumePartition(topic string, partition int32, offset int64) (*PartitionConsumer, error) { @@ -102,7 +102,7 @@ func (c *Consumer) ConsumePartition(topic string, partition int32, offset int64) return WrapPartitionConsumer(pc, c.agent), nil } -func NewConsumer(addrs []string, config *sarama.Config, agent *pinpoint.Agent) (*Consumer, error) { +func NewConsumer(addrs []string, config *sarama.Config, agent pinpoint.Agent) (*Consumer, error) { consumer, err := sarama.NewConsumer(addrs, config) if err != nil { return nil, err diff --git a/sampler_test.go b/sampler_test.go new file mode 100644 index 0000000..05b804c --- /dev/null +++ b/sampler_test.go @@ -0,0 +1,77 @@ +package pinpoint + +import ( + "testing" +) + +func Test_rateSampler_isSampled(t *testing.T) { + type fields struct { + samplingRate uint64 + counter uint64 + } + tests := []struct { + name string + fields fields + want bool + }{ + {"1", fields{1, 0}, true}, + {"2", fields{10, 0}, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &rateSampler{ + samplingRate: tt.fields.samplingRate, + counter: tt.fields.counter, + } + if got := s.isSampled(); got != tt.want { + t.Errorf("rateSampler.isSampled() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_basicTraceSampler_isNewSampled(t *testing.T) { + type fields struct { + baseSampler sampler + } + tests := []struct { + name string + fields fields + want bool + }{ + {"1", fields{newRateSampler(1)}, true}, + {"2", fields{newRateSampler(10)}, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := &basicTraceSampler{ + baseSampler: tt.fields.baseSampler, + } + if got := s.isNewSampled(); got != tt.want { + t.Errorf("basicTraceSampler.isNewSampled() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_throughputLimitTraceSampler_isNewSampled(t *testing.T) { + type fields struct { + sampler traceSampler + } + tests := []struct { + name string + fields fields + want bool + }{ + {"1", fields{newThroughputLimitTraceSampler(newRateSampler(1), 10, 10)}, true}, + {"2", fields{newThroughputLimitTraceSampler(newRateSampler(10), 10, 10)}, false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := tt.fields.sampler + if got := s.isNewSampled(); got != tt.want { + t.Errorf("throughputLimitTraceSampler.isNewSampled() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/span.go b/span.go index bc39774..328b15f 100644 --- a/span.go +++ b/span.go @@ -12,7 +12,7 @@ import ( var asyncIdGen int32 = 0 type span struct { - agent *Agent + agent Agent txId TransactionId spanId int64 parentSpanId int64 @@ -65,7 +65,7 @@ func defaultSpan() *span { return &span } -func newSampledSpan(agent *Agent, operation string) Tracer { +func newSampledSpan(agent Agent, operation string) Tracer { span := defaultSpan() span.agent = agent @@ -85,7 +85,7 @@ func (span *span) EndSpan() { span.duration = time.Now().Sub(span.startTime) collectResponseTime(toMilliseconds(span.duration)) - if !span.agent.tryEnqueueSpan(span) { + if !span.agent.TryEnqueueSpan(span) { log("span").Debug("span channel - max capacity reached or closed") } } @@ -99,8 +99,8 @@ func (span *span) Inject(writer DistributedTracingContextWriter) { writer.Set(HttpParentSpanId, strconv.FormatInt(span.spanId, 10)) writer.Set(HttpFlags, strconv.Itoa(span.flags)) - writer.Set(HttpParentApplicationName, span.agent.config.ApplicationName) - writer.Set(HttpParentApplicationType, strconv.Itoa(int(span.agent.config.ApplicationType))) + writer.Set(HttpParentApplicationName, span.agent.Config().ApplicationName) + writer.Set(HttpParentApplicationType, strconv.Itoa(int(span.agent.Config().ApplicationType))) writer.Set(HttpParentApplicationNamespace, "") se.endPoint = se.destinationId @@ -117,7 +117,7 @@ func (span *span) Extract(reader DistributedTracingContextReader) { span.txId.StartTime, _ = strconv.ParseInt(s[1], 10, 0) span.txId.Sequence, _ = strconv.ParseInt(s[2], 10, 0) } else { - span.txId = span.agent.generateTransactionId() + span.txId = span.agent.GenerateTransactionId() } spanid := reader.Get(HttpSpanId) diff --git a/span_event.go b/span_event.go index 942e2a7..be4f872 100644 --- a/span_event.go +++ b/span_event.go @@ -60,7 +60,7 @@ func (se *spanEvent) SetError(e error) { return } - id := se.parentSpan.agent.cacheErrorFunc(se.operationName) + id := se.parentSpan.agent.CacheErrorFunc(se.operationName) se.errorFuncId = id se.errorString = e.Error() } @@ -88,7 +88,7 @@ func (se *spanEvent) SetSQL(sql string) { normalizer := newSqlNormalizer(sql) nsql, param := normalizer.run() - id := se.parentSpan.agent.cacheSql(nsql) + id := se.parentSpan.agent.CacheSql(nsql) se.annotations.AppendIntStringString(20, id, param, "" /* bind value for prepared stmt */) } diff --git a/span_event_test.go b/span_event_test.go new file mode 100644 index 0000000..bec6c35 --- /dev/null +++ b/span_event_test.go @@ -0,0 +1,121 @@ +package pinpoint + +import ( + "errors" + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +func Test_newSpanEvent(t *testing.T) { + type args struct { + span *span + operationName string + } + tests := []struct { + name string + args args + }{ + {"1", args{defaultSpan(), "t1"}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + se := newSpanEvent(tt.args.span, tt.args.operationName) + assert.Equal(t, se.operationName, tt.args.operationName, "operationName") + assert.Equal(t, se.serviceType, int32(ServiceTypeGoFunction), "serviceType") + assert.NotNil(t, se.startTime, "startTime") + }) + } +} + +func Test_spanEvent_end(t *testing.T) { + type args struct { + span *span + operationName string + } + tests := []struct { + name string + args args + }{ + {"1", args{defaultSpan(), "t1"}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + se := newSpanEvent(tt.args.span, tt.args.operationName) + assert.Equal(t, se.parentSpan.eventDepth, int32(1), "serviceType") + + time.Sleep(100 * time.Millisecond) + se.end() + + assert.Equal(t, se.operationName, tt.args.operationName, "operationName") + assert.Equal(t, se.parentSpan.eventDepth, int32(0), "eventDepth") + assert.Greater(t, se.duration.Milliseconds(), int64(99), "duration") + }) + } +} + +func Test_spanEvent_generateNextSpanId(t *testing.T) { + type args struct { + span *span + operationName string + } + tests := []struct { + name string + args args + }{ + {"1", args{defaultSpan(), "t1"}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + se := newSpanEvent(tt.args.span, tt.args.operationName) + id := se.generateNextSpanId() + assert.Equal(t, se.operationName, tt.args.operationName, "operationName") + assert.Equal(t, se.nextSpanId, id, "nextSpanId") + assert.NotEqual(t, se.nextSpanId, int64(0), "nextSpanId") + }) + } +} + +func Test_spanEvent_SetError(t *testing.T) { + type args struct { + span *span + operationName string + } + tests := []struct { + name string + args args + }{ + {"1", args{defaultSpan(), "t1"}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tt.args.span.agent = newMockAgent() + se := newSpanEvent(tt.args.span, tt.args.operationName) + se.SetError(errors.New("TEST_ERROR")) + assert.Equal(t, se.errorFuncId, int32(1), "errorFuncId") + assert.Equal(t, se.errorString, "TEST_ERROR", "errorString") + }) + } +} + +func Test_spanEvent_SetSQL(t *testing.T) { + type args struct { + span *span + operationName string + } + tests := []struct { + name string + args args + }{ + {"1", args{defaultSpan(), "t1"}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tt.args.span.agent = newMockAgent() + se := newSpanEvent(tt.args.span, tt.args.operationName) + se.SetSQL("SELECT 1") + assert.Equal(t, len(se.annotations.list), int(1), "annotations.len") + }) + } +} diff --git a/span_test.go b/span_test.go index bf053ab..3ad5a15 100644 --- a/span_test.go +++ b/span_test.go @@ -5,7 +5,7 @@ import ( "testing" ) -func TestDefaultSpan(t *testing.T) { +func Test_defaultSpan(t *testing.T) { span := defaultSpan() assert.Equal(t, span.parentSpanId, int64(-1), "parentSpanId") @@ -15,3 +15,154 @@ func TestDefaultSpan(t *testing.T) { assert.Equal(t, span.serviceType, int32(ServiceTypeGoApp), "serviceType") assert.NotNil(t, span.stack, "stack") } + +type DistributedTracingContextMap struct { + m map[string]string +} + +func (r *DistributedTracingContextMap) Get(key string) string { + return r.m[key] +} + +func (r *DistributedTracingContextMap) Set(key string, val string) { + r.m[key] = val +} + +func Test_span_Extract(t *testing.T) { + type args struct { + reader DistributedTracingContextReader + } + + m := map[string]string{ + HttpTraceId: "t123456^12345^1", + HttpSpanId: "67890", + HttpParentSpanId: "123", + } + + tests := []struct { + name string + args args + }{ + {"1", args{&DistributedTracingContextMap{m}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + span := defaultSpan() + span.Extract(tt.args.reader) + + assert.Equal(t, span.txId.AgentId, "t123456", "AgentId") + assert.Equal(t, span.txId.StartTime, int64(12345), "StartTime") + assert.Equal(t, span.txId.Sequence, int64(1), "Sequence") + assert.Equal(t, span.spanId, int64(67890), "spanId") + assert.Equal(t, span.parentSpanId, int64(123), "parentSpanId") + }) + } +} + +func Test_span_Inject(t *testing.T) { + type args struct { + writer DistributedTracingContextWriter + } + + m := make(map[string]string) + + tests := []struct { + name string + args args + }{ + {"1", args{&DistributedTracingContextMap{m}}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + span := defaultSpan() + span.agent = newMockAgent() + span.txId.AgentId = "t123456" + span.txId.StartTime = int64(12345) + span.txId.Sequence = int64(1) + span.NewSpanEvent("t") + + span.Inject(tt.args.writer) + assert.Equal(t, m[HttpTraceId], span.txId.String(), "HttpTraceId") + }) + } +} + +func Test_span_NewSpanEvent(t *testing.T) { + type args struct { + operationName string + } + tests := []struct { + name string + args args + }{ + {"1", args{"t1"}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + span := defaultSpan() + span.NewSpanEvent(tt.args.operationName) + assert.Equal(t, span.eventSequence, int32(1), "eventSequence") + assert.Equal(t, span.eventDepth, int32(2), "eventDepth") + assert.Equal(t, span.stack.Len(), int(1), "stack.len") + + se := span.spanEvents[0] + assert.Equal(t, se.operationName, tt.args.operationName, "operationName") + }) + } +} + +func Test_span_EndSpanEvent(t *testing.T) { + type args struct { + operationName string + } + tests := []struct { + name string + args args + }{ + {"1", args{"t1"}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + span := defaultSpan() + span.NewSpanEvent(tt.args.operationName) + span.NewSpanEvent("t2") + assert.Equal(t, span.stack.Len(), int(2), "stack.len") + span.EndSpanEvent() + assert.Equal(t, span.stack.Len(), int(1), "stack.len") + span.EndSpanEvent() + assert.Equal(t, span.stack.Len(), int(0), "stack.len") + }) + } +} + +func Test_span_NewAsyncSpan(t *testing.T) { + type args struct { + operationName string + } + tests := []struct { + name string + args args + }{ + {"1", args{"t1"}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + s := defaultSpan() + s.agent = newMockAgent() + s.NewSpanEvent(tt.args.operationName) + a := s.NewAsyncSpan() + + se := s.stack.Front().Value.(*spanEvent) + assert.Equal(t, se.asyncId, int32(1), "asyncId") + assert.Equal(t, se.asyncSeqGen, int32(1), "asyncSeqGen") + + as := a.(*span) + assert.Equal(t, as.agent, s.agent, "agent") + assert.Equal(t, as.txId, s.txId, "txId") + assert.Equal(t, as.spanId, s.spanId, "spanId") + + ase := as.stack.Front().Value.(*spanEvent) + assert.Equal(t, ase.serviceType, int32(100), "serviceType") + }) + } +} diff --git a/stats.go b/stats.go index 636b203..bac31ea 100644 --- a/stats.go +++ b/stats.go @@ -139,7 +139,7 @@ func calcResponseAvg() int64 { return 0 } -func collectStats(agent *Agent) { +func (agent *agent) sendStatsWorker() { log("stats").Info("stat goroutine start") defer agent.wg.Done() @@ -149,7 +149,7 @@ func collectStats(agent *Agent) { sleepTime := time.Duration(agent.config.Stat.CollectInterval) * time.Millisecond time.Sleep(sleepTime) - statStream := agent.statGrpc.newStatStreamWithRetry() + agent.statStream = agent.statGrpc.newStatStreamWithRetry() collected := make([]*inspectorStats, agent.config.Stat.BatchCount) batch := 0 @@ -162,11 +162,15 @@ func collectStats(agent *Agent) { batch++ if batch == agent.config.Stat.BatchCount { - err := statStream.sendStats(collected) + agent.statStreamReq = true + err := agent.statStream.sendStats(collected) + agent.statStreamReq = false + agent.statStreamReqCount++ + if err != nil { log("stats").Errorf("fail to sendStats(): %v", err) - statStream.close() - statStream = agent.statGrpc.newStatStreamWithRetry() + agent.statStream.close() + agent.statStream = agent.statGrpc.newStatStreamWithRetry() } batch = 0 } @@ -174,7 +178,7 @@ func collectStats(agent *Agent) { time.Sleep(sleepTime) } - statStream.close() + agent.statStream.close() log("stats").Info("stat goroutine finish") } diff --git a/tracer.go b/tracer.go index 86ea702..114c1e2 100644 --- a/tracer.go +++ b/tracer.go @@ -15,6 +15,21 @@ func (tid TransactionId) String() string { return fmt.Sprintf("%s^%d^%d", tid.AgentId, tid.StartTime, tid.Sequence) } +type Agent interface { + Shutdown() + NewSpanTracer(operation string) Tracer + NewSpanTracerWithReader(operation string, reader DistributedTracingContextReader) Tracer + RegisterSpanApiId(descriptor string, apiType int) int32 + Config() Config + GenerateTransactionId() TransactionId + TryEnqueueSpan(span *span) bool + Enable() bool + StartTime() int64 + CacheErrorFunc(funcname string) int32 + CacheSql(sql string) int32 + CacheSpanApiId(descriptor string, apiType int) int32 +} + type Tracer interface { NewSpanEvent(operationName string) Tracer NewAsyncSpan() Tracer