func (l *loggerType) reportNewNamesForSuggest( list metrics.List) { length := list.Len() for i := 0; i < length; i++ { var value metrics.Value list.Index(i, &value) if types.FromGoValue(value.Value).CanToFromFloat() { if !l.NamesSentToSuggest[value.Path] { l.MetricNameAdder.Add(value.Path) l.NamesSentToSuggest[value.Path] = true } } } }
// LookupBatch looks up all the metrics in one go and returns the // following: // fetched: timeSeries already in this collection keyed by Metric. // values must be added to these manually. // newOnes: timeSeries just added as a result of this lookup. Since these // are new, the first value added automatically. // notFetched: timeSeries in this collection but not fetched. These // are the time series that should be marked inactive. // ok is true if metrics can be added to this instance or false if this // instance is inactive and closed for new metrics. func (c *timeSeriesCollectionType) LookupBatch( timestamp float64, mlist metrics.List) ( fetched map[*timeSeriesType]interface{}, newOnes, notFetched []*timeSeriesType, fetchedTimeStamps map[*timestampSeriesType]float64, newTs []*timestampSeriesType, notFetchedTimeStamps []*timestampSeriesType, err error) { if err = metrics.VerifyList(mlist); err != nil { return } c.lock.Lock() defer c.lock.Unlock() if !c.active { err = ErrInactive return } valueByMetric := make(map[*MetricInfo]interface{}) timestampByGroupId := make(map[int]float64) groupIds := make(map[int]bool) fetched = make(map[*timeSeriesType]interface{}) fetchedTimeStamps = make(map[*timestampSeriesType]float64) mlen := mlist.Len() for i := 0; i < mlen; i++ { var avalue metrics.Value mlist.Index(i, &avalue) kind, subType := types.FromGoValueWithSubType(avalue.Value) id := c.metricInfoStore.Register(&avalue, kind, subType) if kind == types.Dist { distributionRollOvers := c.distributionRollOversByPath[avalue.Path] if distributionRollOvers == nil { distributionRollOvers = &distributionRollOverType{} c.distributionRollOversByPath[avalue.Path] = distributionRollOvers } distribution := avalue.Value.(*messages.Distribution) rollOverCount := distributionRollOvers.UpdateAndFetchRollOverCount( id.Ranges(), distribution.Generation) currentDistributionTotals := &DistributionTotals{ Counts: distExtractCounts(distribution), Sum: distribution.Sum, RollOverCount: rollOverCount, } valueByMetric[id] = currentDistributionTotals } else { valueByMetric[id] = avalue.Value } groupIds[id.GroupId()] = true if !avalue.TimeStamp.IsZero() { timestampByGroupId[id.GroupId()] = duration.TimeToFloat(avalue.TimeStamp) } } // If a group ID is missing a timestamp, give it the // timestamp from scotty. for groupId := range groupIds { if _, ok := timestampByGroupId[groupId]; !ok { timestampByGroupId[groupId] = timestamp } } // populate notFetched for id, series := range c.timeSeries { if _, ok := valueByMetric[id]; !ok { notFetched = append(notFetched, series) } } // populate fetched and newOnes for id, value := range valueByMetric { if c.timeSeries[id] == nil { thisTs := timestampByGroupId[id.GroupId()] c.timeSeries[id] = newTimeSeriesType( id, thisTs, value, c.metrics) newOnes = append(newOnes, c.timeSeries[id]) } else { fetched[c.timeSeries[id]] = value } } // populate notFetchedTimeStamps for groupId, series := range c.timestampSeries { if _, ok := timestampByGroupId[groupId]; !ok { notFetchedTimeStamps = append( notFetchedTimeStamps, series) } } // populate fetchedTimeStamps and newTs for groupId, ts := range timestampByGroupId { if c.timestampSeries[groupId] == nil { c.timestampSeries[groupId] = newTimeStampSeriesType( groupId, ts, c.metrics) newTs = append(newTs, c.timestampSeries[groupId]) } else { fetchedTimeStamps[c.timestampSeries[groupId]] = ts } } return }