func (t *Topic) AggregateChannelE2eProcessingLatency() *util.Quantile {
var latencyStream *util.Quantile
for _, c := range t.channelMap {
if c.e2eProcessingLatencyStream == nil {
continue
}
if latencyStream == nil {
latencyStream = util.NewQuantile(
t.context.nsqd.options.e2eProcessingLatencyWindowTime,
t.context.nsqd.options.e2eProcessingLatencyPercentiles)
}
latencyStream.Merge(c.e2eProcessingLatencyStream)
}
return latencyStream
}
// NewChannel creates a new instance of the Channel type and returns a pointer
func NewChannel(topicName string, channelName string, context *Context,
deleteCallback func(*Channel)) *Channel {
c := &Channel{
topicName: topicName,
name: channelName,
incomingMsgChan: make(chan *nsq.Message, 1),
memoryMsgChan: make(chan *nsq.Message, context.nsqd.options.memQueueSize),
clientMsgChan: make(chan *nsq.Message),
exitChan: make(chan int),
clients: make(map[int64]Consumer),
deleteCallback: deleteCallback,
context: context,
}
if len(context.nsqd.options.e2eProcessingLatencyPercentiles) > 0 {
c.e2eProcessingLatencyStream = util.NewQuantile(
context.nsqd.options.e2eProcessingLatencyWindowTime,
context.nsqd.options.e2eProcessingLatencyPercentiles,
)
}
c.initPQ()
if strings.HasSuffix(channelName, "#ephemeral") {
c.ephemeralChannel = true
c.backend = NewDummyBackendQueue()
} else {
// backend names, for uniqueness, automatically include the topic... <topic>:<channel>
backendName := topicName + ":" + channelName
c.backend = NewDiskQueue(backendName,
context.nsqd.options.dataPath,
context.nsqd.options.maxBytesPerFile,
context.nsqd.options.syncEvery,
context.nsqd.options.syncTimeout)
}
go c.messagePump()
c.waitGroup.Wrap(func() { c.router() })
c.waitGroup.Wrap(func() { c.deferredWorker() })
c.waitGroup.Wrap(func() { c.inFlightWorker() })
go c.context.nsqd.Notify(c)
return c
}