func newTestApp(replyfn func(*internal.ConnectReply), cfg Config) (expectApp, error) {
cfg.Enabled = false
application, err := newApp(cfg)
if nil != err {
return nil, err
}
app := application.(*app)
if nil != replyfn {
reply := internal.ConnectReplyDefaults()
replyfn(reply)
app.setState(&internal.AppRun{ConnectReply: reply}, nil)
}
app.testHarvest = internal.NewHarvest(time.Now())
return app, nil
}
func debug(data internal.Harvestable, lg Logger) {
now := time.Now()
h := internal.NewHarvest(now)
data.MergeIntoHarvest(h)
ps := h.Payloads()
for cmd, p := range ps {
d, err := p.Data("agent run id", now)
if nil == d && nil == err {
continue
}
if nil != err {
lg.Debug("integration", map[string]interface{}{
"cmd": cmd,
"error": err.Error(),
})
continue
}
lg.Debug("integration", map[string]interface{}{
"cmd": cmd,
"data": internal.JSONString(d),
})
}
}
func (app *app) process() {
// Both the harvest and the run are non-nil when the app is connected,
// and nil otherwise.
var h *internal.Harvest
var run *internal.AppRun
for {
select {
case <-app.harvestTicker.C:
if nil != run {
now := time.Now()
go app.doHarvest(h, now, run)
h = internal.NewHarvest(now)
}
case d := <-app.dataChan:
if nil != run && run.RunID == d.id {
d.data.MergeIntoHarvest(h)
}
case <-app.initiateShutdown:
close(app.shutdownStarted)
// Remove the run before merging any final data to
// ensure a bounded number of receives from dataChan.
app.setState(nil, errors.New("application shut down"))
app.harvestTicker.Stop()
if nil != run {
for done := false; !done; {
select {
case d := <-app.dataChan:
if run.RunID == d.id {
d.data.MergeIntoHarvest(h)
}
default:
done = true
}
}
app.doHarvest(h, time.Now(), run)
}
close(app.shutdownComplete)
return
case err := <-app.collectorErrorChan:
run = nil
h = nil
app.setState(nil, nil)
switch {
case internal.IsDisconnect(err):
app.setState(nil, err)
app.config.Logger.Error("application disconnected by New Relic", map[string]interface{}{
"app": app.config.AppName,
})
case internal.IsLicenseException(err):
app.setState(nil, err)
app.config.Logger.Error("invalid license", map[string]interface{}{
"app": app.config.AppName,
"license": app.config.License,
})
case internal.IsRestartException(err):
app.config.Logger.Info("application restarted", map[string]interface{}{
"app": app.config.AppName,
})
go app.connectRoutine()
}
case run = <-app.connectChan:
h = internal.NewHarvest(time.Now())
app.setState(run, nil)
app.config.Logger.Info("application connected", map[string]interface{}{
"app": app.config.AppName,
"run": run.RunID.String(),
})
processConnectMessages(run, app.config.Logger)
}
}
}