// NewChannel creates a new instance of the Channel type and returns a pointer
func NewChannel(topicName string, channelName string, ctx *context,
deleteCallback func(*Channel)) *Channel {
c := &Channel{
topicName: topicName,
name: channelName,
memoryMsgChan: make(chan *Message, ctx.nsqd.getOpts().MemQueueSize),
clientMsgChan: make(chan *Message),
exitChan: make(chan int),
clients: make(map[int64]Consumer),
deleteCallback: deleteCallback,
ctx: ctx,
}
if len(ctx.nsqd.getOpts().E2EProcessingLatencyPercentiles) > 0 {
c.e2eProcessingLatencyStream = quantile.New(
ctx.nsqd.getOpts().E2EProcessingLatencyWindowTime,
ctx.nsqd.getOpts().E2EProcessingLatencyPercentiles,
)
}
c.initPQ()
if strings.HasSuffix(channelName, "#ephemeral") {
c.ephemeral = true
c.backend = newDummyBackendQueue()
} else {
// backend names, for uniqueness, automatically include the topic...
backendName := getBackendName(topicName, channelName, false)
c.backend = newDiskQueue(backendName,
ctx.nsqd.getOpts().DataPath,
ctx.nsqd.getOpts().MaxBytesPerFile,
int32(minValidMsgLength),
int32(ctx.nsqd.getOpts().MaxMsgSize)+minValidMsgLength,
ctx.nsqd.getOpts().SyncEvery,
ctx.nsqd.getOpts().SyncTimeout,
ctx.nsqd.getOpts().Logger)
backendName = getBackendName(topicName, channelName, true)
c.backendDeferred = newDiskQueue(backendName,
ctx.nsqd.getOpts().DataPath,
ctx.nsqd.getOpts().MaxBytesPerFile,
int32(minValidMsgLength),
int32(ctx.nsqd.getOpts().MaxMsgSize),
ctx.nsqd.getOpts().SyncEvery,
ctx.nsqd.getOpts().SyncTimeout,
ctx.nsqd.getOpts().Logger)
}
go c.messagePump()
go c.loadDeferredQueueFromBackend()
c.ctx.nsqd.Notify(c)
return c
}
func (t *Topic) AggregateChannelE2eProcessingLatency() *quantile.Quantile {
var latencyStream *quantile.Quantile
for _, c := range t.channelMap {
if c.e2eProcessingLatencyStream == nil {
continue
}
if latencyStream == nil {
latencyStream = quantile.New(
t.ctx.nsqd.getOpts().E2EProcessingLatencyWindowTime,
t.ctx.nsqd.getOpts().E2EProcessingLatencyPercentiles)
}
latencyStream.Merge(c.e2eProcessingLatencyStream)
}
return latencyStream
}
func (t *Topic) AggregateChannelE2eProcessingLatency() *quantile.Quantile {
var latencyStream *quantile.Quantile
t.RLock()
realChannels := make([]*Channel, 0, len(t.channelMap))
for _, c := range t.channelMap {
realChannels = append(realChannels, c)
}
t.RUnlock()
for _, c := range realChannels {
if c.e2eProcessingLatencyStream == nil {
continue
}
if latencyStream == nil {
latencyStream = quantile.New(
t.ctx.nsqd.getOpts().E2EProcessingLatencyWindowTime,
t.ctx.nsqd.getOpts().E2EProcessingLatencyPercentiles)
}
latencyStream.Merge(c.e2eProcessingLatencyStream)
}
return latencyStream
}