public void Write(MetricValue metric) { if (metric == null) { Logger.Debug("write() - Invalid null metric"); return; } if (!_connected) StartConnection(); if (_connected && _channel != null) { string routingKey = GetAmqpRoutingKey(metric); string message = metric.GetMetricJsonStr(); try { _channel.BasicPublish(_exchange, routingKey, null, Encoding.UTF8.GetBytes(message)); } catch { CloseConnection(); } } }
public IList<MetricValue> Read() { if (DateTime.Now > _configurationReloadTime.AddSeconds(_reloadConfigurationInterval)) { Logger.Info("WindowsPerformanceCounter reloading configuration"); Configure(); } var metricValueList = new List<MetricValue>(); foreach (Metric metric in _metrics) { var vals = new List<double>(); var missingInstances = new List<PerformanceCounter>(); foreach (PerformanceCounter ctr in metric.Counters) { double val; try { val = ctr.NextValue(); } catch (InvalidOperationException) { // The instance is gone missingInstances.Add(ctr); continue; } if (metric.ScaleUpFactor > 0) { val = val*metric.ScaleUpFactor; } else { if (metric.ScaleDownFactor > 0) { val = val/metric.ScaleDownFactor; } } vals.Add(val); } foreach (PerformanceCounter missingInstance in missingInstances) { string logstr = string.Format( "Category:{0} - Instance:{1} - counter:{2} - ScaleUpFactor:{3} - ScaleDownFactor:{4} - CollectdPlugin:{5} - CollectdPluginInstance:{6} - CollectdType:{7} - CollectdTypeInstance:{8}", metric.Category, metric.Instance, metric.CounterName, metric.ScaleUpFactor, metric.ScaleDownFactor, metric.CollectdPlugin, metric.CollectdPluginInstance, metric.CollectdType, metric.CollectdTypeInstance); Logger.Info("Removed Performance COUNTER : {0}", logstr); metric.Counters.Remove(missingInstance); } var metricValue = new MetricValue { HostName = _hostName, PluginName = metric.CollectdPlugin, PluginInstanceName = metric.CollectdPluginInstance, TypeName = metric.CollectdType, TypeInstanceName = metric.CollectdTypeInstance, Values = vals.ToArray() }; TimeSpan t = DateTime.UtcNow - new DateTime(1970, 1, 1); double epoch = t.TotalMilliseconds/1000; metricValue.Epoch = Math.Round(epoch, 3); metricValueList.Add(metricValue); } return (metricValueList); }
public void Write(MetricValue metric) { // Optoinal Regex replace of unsafe chars if (SafeCharsRegex != null) { metric.PluginInstanceName = SafeCharsRegex.Replace(metric.PluginInstanceName, ReplaceWith); } string message = metric.GetMetricJsonStr(); if (_batchedMetricStr == null) { _batchedMetricStr = new StringBuilder("[").Append(message); } else { _batchedMetricStr.Append(",").Append(message); } _numMetrics++; if (_numMetrics < BatchSize) return; publish(); }
public void Write(MetricValue metric) { if (metric == null) { Logger.Debug("write() - Invalid null metric"); return; } foreach (HttpWriter writer in _httpWriters) { writer.Write(metric); } }
public void Aggregate(ref MetricValue metricValue) { // If rates are not stored then there is nothing to aggregate if (!_storeRates) { return; } IList<DataSource> dsl = DataSetCollection.Instance.GetDataSource(metricValue.TypeName); if (dsl == null || metricValue.Values.Length != dsl.Count) { return; } double now = Util.GetNow(); lock (_cacheLock) { CacheEntry cEntry; string key = metricValue.Key(); if (!(_cache.TryGetValue(key, out cEntry))) { cEntry = new CacheEntry(metricValue.DeepCopy()); for (int i = 0; i < metricValue.Values.Length; i++) { if (dsl[i].Type == DsType.Derive || dsl[i].Type == DsType.Absolute || dsl[i].Type == DsType.Counter) { metricValue.Values[i] = double.NaN; cEntry.MetricRate.Values[i] = double.NaN; } } cEntry.MetricRate.Epoch = now; _cache[key] = cEntry; return; } for (int i = 0; i < metricValue.Values.Length; i++) { double rawValNew = metricValue.Values[i]; double rawValOld = cEntry.RawValues[i]; double rawValDiff = rawValNew - rawValOld; double timeDiff = cEntry.MetricRate.Epoch - now; double rateNew = rawValDiff/timeDiff; switch (dsl[i].Type) { case DsType.Gauge: // no rates calculations are done, values are stored as-is for gauge cEntry.RawValues[i] = rawValNew; cEntry.MetricRate.Values[i] = rawValNew; break; case DsType.Absolute: // similar to gauge, except value will be divided by time diff cEntry.MetricRate.Values[i] = metricValue.Values[i]/timeDiff; cEntry.RawValues[i] = rawValNew; metricValue.Values[i] = cEntry.MetricRate.Values[i]; break; case DsType.Derive: cEntry.RawValues[i] = rawValNew; cEntry.MetricRate.Values[i] = rateNew; metricValue.Values[i] = rateNew; break; case DsType.Counter: // Counters are very simlar to derive except when counter wraps around if (rawValNew < rawValOld) { // counter has wrapped around cEntry.MetricRate.Values[i] = metricValue.Values[i]/timeDiff; cEntry.RawValues[i] = rawValNew; metricValue.Values[i] = cEntry.MetricRate.Values[i]; } else { cEntry.MetricRate.Values[i] = rateNew; cEntry.RawValues[i] = rawValNew; metricValue.Values[i] = rateNew; } break; } // range checks if (metricValue.Values[i] < dsl[i].Min) { metricValue.Values[i] = dsl[i].Min; cEntry.RawValues[i] = metricValue.Values[i]; } if (metricValue.Values[i] > dsl[i].Max) { metricValue.Values[i] = dsl[i].Max; cEntry.RawValues[i] = metricValue.Values[i]; } cEntry.MetricRate.Epoch = now; _cache[key] = cEntry; } } }
public void Write(MetricValue metric) { string message = metric.GetMetricJsonStr(); if (_batchedMetricStr == null) { _batchedMetricStr = new StringBuilder("[").Append(message); } else { _batchedMetricStr.Append(",").Append(message); } _numMetrics++; if (_numMetrics < BatchSize) return; _batchedMetricStr.Append("]"); HttpPost(_batchedMetricStr.ToString()); _batchedMetricStr = null; _numMetrics = 0; }
public IList<CollectableValue> Read() { // Only collect events and event metric every nth interval if (_intervalCounter++ % _intervalMultiplier != 0) return new List<CollectableValue>(); IList<CollectableValue> collectableValues = new List<CollectableValue>(); long totalEvents = 0; long collectionTime = (long)(Util.toEpoch(DateTime.UtcNow)); List<long> recordIds = new List<long>(); foreach (EventQuery eventQuery in _events) { List<EventRecord> records = GetEventRecords(eventQuery.minLevel, eventQuery.maxLevel, eventQuery.log, eventQuery.source); // Filter the events - event ID must be in target range, description must match regex and we mustn't have already read this event record ID in another query Regex filterExp = new Regex(eventQuery.filterExp, RegexOptions.None); List<EventRecord> filteredRecords = records.FindAll(delegate(EventRecord record) { return !recordIds.Contains((long)record.RecordId) && record.Id >= eventQuery.minEventId && record.Id <= eventQuery.maxEventId && filterExp.IsMatch(record.FormatDescription()); }); // Add these record IDs to dedupe list so we don't capture them again in a later query filteredRecords.ForEach(delegate(EventRecord record) { recordIds.Add((long)record.RecordId); }); if (filteredRecords.Count <= eventQuery.maxPerCycle) { foreach (EventRecord record in filteredRecords) { // Timestamp from record is machine time, not GMT long timestamp = (long)(Util.toEpoch(record.TimeCreated.Value.ToUniversalTime())); long id = (long)record.RecordId; string message = record.FormatDescription(); EventValue newevent = new EventValue(_hostName, timestamp, record.Level.Value, eventQuery.title, message, id); collectableValues.Add(newevent); totalEvents++; } } else { // Too many events - summarise by counting events by application,level and code Dictionary<string, int> detailMap = new Dictionary<string, int>(); int minLevel = 999; // used to get the most severe event in the period for the summary level filteredRecords.ForEach(delegate(EventRecord record) { string key = string.Format("{0} in {1} ({2})", record.LevelDisplayName, record.ProviderName, record.Id); if (record.Level.Value < minLevel) minLevel = record.Level.Value; if (detailMap.ContainsKey(key)) { detailMap[key] = detailMap[key] + 1; } else { detailMap.Add(key, 1); } }); List<KeyValuePair<string, int>> detailList = new List<KeyValuePair<string, int>>(); foreach (string key in detailMap.Keys) { detailList.Add(new KeyValuePair<string, int>(key, detailMap[key])); } detailList.Sort(delegate(KeyValuePair<string, int> pair1, KeyValuePair<string, int> pair2) { return -pair1.Value.CompareTo(pair2.Value); }); string[] messageLines = new string[detailList.Count]; int ix = 0; foreach (KeyValuePair<string, int> pair in detailList) { messageLines[ix++] = pair.Value + " x " + pair.Key; } string title = string.Format("{0} ({1} events)", eventQuery.title, filteredRecords.Count); EventValue newevent = new EventValue(_hostName, collectionTime, minLevel, title, String.Join(", ", messageLines), 0); collectableValues.Add(newevent); totalEvents += filteredRecords.Count; } } // Add event count metric MetricValue eventCountMetric = new MetricValue { HostName = _hostName, PluginName = "windows_events", PluginInstanceName = "", TypeName = "count", TypeInstanceName = "event_count", Values = new double[] { totalEvents }, FriendlyNames = new string[] { "Windows Event Count" }, Epoch = collectionTime }; collectableValues.Add(eventCountMetric); return collectableValues; }
public IList<MetricValue> Read() { lock (_lock) { var res = new List<MetricValue>(); var removeList = new List<string>(); foreach (var pair in _metrics) { StatsdMetric metric = pair.Value; if (metric.NumUpdates <= 0 && ((_delCounter && metric.Type == StatsdMetric.StatsdType.StatsdCounter) || (_delTimer && metric.Type == StatsdMetric.StatsdType.StatsdTimer) || (_delGauge && metric.Type == StatsdMetric.StatsdType.StatsdGauge) || (_delSet && metric.Type == StatsdMetric.StatsdType.StatsdSet))) { removeList.Add(pair.Key); continue; } var metricVal = new MetricValue { HostName = _hostName, PluginName = "statsd", PluginInstanceName = "", TypeInstanceName = metric.Name, Values = new[] {metric.GetMetric()} }; switch (metric.Type) { case StatsdMetric.StatsdType.StatsdGauge: metricVal.TypeName = "gauge"; break; case StatsdMetric.StatsdType.StatsdTimer: metricVal.TypeName = "latency"; metricVal.TypeInstanceName += "-average"; break; case StatsdMetric.StatsdType.StatsdSet: metricVal.TypeName = "objects"; break; default: metricVal.TypeName = "derive"; break; } TimeSpan t = DateTime.UtcNow - new DateTime(1970, 1, 1); double epoch = t.TotalMilliseconds/1000; metricVal.Epoch = Math.Round(epoch, 3); res.Add(metricVal); if (metric.Type == StatsdMetric.StatsdType.StatsdTimer) { if (_timerLower) { MetricValue lowerValue = metricVal.DeepCopy(); lowerValue.TypeInstanceName = metric.Name + "-lower"; lowerValue.Values[0] = metric.Lat.Min; res.Add(lowerValue); } if (_timerUpper) { MetricValue upperValue = metricVal.DeepCopy(); upperValue.TypeInstanceName = metric.Name + "-upper"; upperValue.Values[0] = metric.Lat.Max; res.Add(upperValue); } if (_timerSum) { MetricValue upperSum = metricVal.DeepCopy(); upperSum.TypeInstanceName = metric.Name + "-Sum"; upperSum.Values[0] = metric.Lat.Sum; res.Add(upperSum); } if (_timerCount) { MetricValue upperCount = metricVal.DeepCopy(); upperCount.TypeInstanceName = metric.Name + "-count"; upperCount.Values[0] = metric.Lat.Num; res.Add(upperCount); } Histogram histogram = metric.Lat.Histogram; if (_percentiles != null && _percentiles.Length > 0 && histogram != null) { foreach (float percentile in _percentiles) { double val = histogram.GetPercentile(percentile); MetricValue mv = metricVal.DeepCopy(); mv.TypeInstanceName = metric.Name + "-percentile-" + percentile; mv.Values[0] = val; res.Add(mv); } } } metric.Reset(); } Logger.Debug("Removing entries that were not updated:{0}", removeList.Count); foreach (string key in removeList) { _metrics.Remove(key); } return (res); } }
public IList<CollectableValue> Read() { // Check if it is time to reload the metric config // We need to periodially reload the config in case new instances or new categories are available (e.g. due to cluster move) if (Util.GetNow() - _lastUpdated >= _reloadInterval) { Configure(); } var metricValueList = new List<CollectableValue>(); foreach (Metric metric in _metrics) { try { var vals = new List<double>(); foreach (PerformanceCounter ctr in metric.Counters) { double val = ctr.NextValue(); val = val * metric.Multiplier; if (metric.DecimalPlaces >= 0) val = Math.Round(val, metric.DecimalPlaces); vals.Add(val); } var metricValue = new MetricValue { HostName = _hostName, PluginName = metric.CollectdPlugin, PluginInstanceName = metric.CollectdPluginInstance, TypeName = metric.CollectdType, TypeInstanceName = metric.CollectdTypeInstance, Values = vals.ToArray(), FriendlyNames = metric.FriendlyNames }; metricValue.Epoch = Util.toEpoch(DateTime.UtcNow); metricValueList.Add(metricValue); } catch (Exception ex) { Logger.Warn(string.Format("Failed to collect metric: {0}, {1}, {2}", metric.Category, metric.Instance, metric.CounterName), ex); } } return (metricValueList); }
public void Write(MetricValue metric) { Console.WriteLine("ConsolePlugin: {0}", metric.GetMetricJsonStr()); }
public IList <MetricValue> Read() { if (DateTime.Now > _configurationReloadTime.AddSeconds(_reloadConfigurationInterval)) { Logger.Info("WindowsPerformanceCounter reloading configuration"); Configure(); } var metricValueList = new List <MetricValue>(); foreach (Metric metric in _metrics) { var vals = new List <double>(); var missingInstances = new List <PerformanceCounter>(); foreach (PerformanceCounter ctr in metric.Counters) { double val; try { val = ctr.NextValue(); } catch (InvalidOperationException) { // The instance is gone missingInstances.Add(ctr); continue; } if (metric.ScaleUpFactor > 0) { val = val * metric.ScaleUpFactor; } else { if (metric.ScaleDownFactor > 0) { val = val / metric.ScaleDownFactor; } } vals.Add(val); } foreach (PerformanceCounter missingInstance in missingInstances) { string logstr = string.Format( "Category:{0} - Instance:{1} - counter:{2} - ScaleUpFactor:{3} - ScaleDownFactor:{4} - CollectdPlugin:{5} - CollectdPluginInstance:{6} - CollectdType:{7} - CollectdTypeInstance:{8}", metric.Category, metric.Instance, metric.CounterName, metric.ScaleUpFactor, metric.ScaleDownFactor, metric.CollectdPlugin, metric.CollectdPluginInstance, metric.CollectdType, metric.CollectdTypeInstance); Logger.Info("Removed Performance COUNTER : {0}", logstr); metric.Counters.Remove(missingInstance); } var metricValue = new MetricValue { HostName = _hostName, PluginName = metric.CollectdPlugin, PluginInstanceName = metric.CollectdPluginInstance, TypeName = metric.CollectdType, TypeInstanceName = metric.CollectdTypeInstance, Values = vals.ToArray() }; TimeSpan t = DateTime.UtcNow - new DateTime(1970, 1, 1); double epoch = t.TotalMilliseconds / 1000; metricValue.Epoch = Math.Round(epoch, 3); metricValueList.Add(metricValue); } return(metricValueList); }
private void WriteThreadProc() { Logger.Trace("WriteThreadProc() begin"); // Wait a few seconds to give read thread a chance to get metrics. // Otherwise write thread is always pushing metrics _interval seconds after they were read Thread.Sleep(15000); while (_runWriteThread) { try { double writeStart = Util.GetNow(); int numValues = _collectedValueQueue.Count; if (numValues > 0) { // Transfer current queue contents to working list // Individual write plugins can choose how to handle the list of collectable values. Queue <CollectableValue> collectedValues = new Queue <CollectableValue>(); lock (_queueLock) { while (_collectedValueQueue.Count > 0) { collectedValues.Enqueue(_collectedValueQueue.Dequeue()); } } if (collectedValues.Count > 0) { foreach (CollectableValue collectedValue in collectedValues) { collectedValue.Interval = _interval; if (collectedValue is MetricValue) { MetricValue metricValue = (MetricValue)collectedValue; _aggregator.Aggregate(ref metricValue); } } foreach (ICollectdPlugin plugin in _plugins) { var writePlugin = plugin as ICollectdWritePlugin; if (writePlugin == null) { // skip if plugin is not a writeplugin continue; } writePlugin.Write(collectedValues); } } } double writeEnd = Util.GetNow(); double elapsed = writeEnd - writeStart; double revisedInterval = (_interval - elapsed) * 1000; if (revisedInterval / _interval < 0.1) { Logger.Warn("Write thread took {0} seconds out of {1} second cycle", elapsed, _interval); } if (revisedInterval >= 0) { Thread.Sleep((int)revisedInterval); } else { LogEventInfo logEvent = new LogEventInfo(LogLevel.Error, Logger.Name, "Write thread exceeded cycle time"); logEvent.Properties.Add("EventID", ErrorCodes.ERROR_WRITE_EXCEEDED_CYCLE_TIME); Logger.Log(logEvent); } } catch (ThreadInterruptedException) { Logger.Info("Write thread interrupted"); } catch (Exception exp) { LogEventInfo logEvent = new LogEventInfo(LogLevel.Error, Logger.Name, "Exception in WriteThreadProc()"); logEvent.Exception = exp; logEvent.Properties.Add("EventID", ErrorCodes.ERROR_UNHANDLED_EXCEPTION); Logger.Log(logEvent); Thread.Sleep(_interval * 1000); } } Logger.Trace("WriteThreadProc() return"); }
private void WriteThreadProc() { Logger.Trace("WriteThreadProc() begin"); bool needToFlush = false; while (_runWriteThread) { try { while (_metricValueQueue.Count > 0) { MetricValue metricValue = null; lock (_queueLock) { if (_metricValueQueue.Count > 0) { metricValue = _metricValueQueue.Dequeue(); } } if (metricValue != null) { needToFlush = true; metricValue.Interval = _interval; _aggregator.Aggregate(ref metricValue); metricValue.AddMetaData(_metaData); foreach (IMetricsPlugin plugin in _plugins) { var writePlugin = plugin as IMetricsWritePlugin; if (writePlugin == null) { // skip if plugin is not a writeplugin, it might be a readplugin continue; } writePlugin.Write(metricValue); } } } if (needToFlush) { needToFlush = false; foreach (IMetricsPlugin plugin in _plugins) { var writePlugin = plugin as IMetricsWritePlugin; if (writePlugin != null) { // flush only if it is a Write plugin writePlugin.Flush(); } } } if (_metricValueQueue.Count <= 0) { Thread.Sleep(1000); } } catch (Exception exp) { Logger.Error("WriteThreadProc() got exception : ", exp); } } Logger.Trace("WriteThreadProc() return"); }
public CacheEntry(MetricValue metricValue) { MetricRate = metricValue; RawValues = (double[])metricValue.Values.Clone(); }
private string GetAmqpRoutingKey(MetricValue metric) { string routingKey = _routingKeyPrefix + "." + metric.HostName + "." + metric.PluginName + "." + metric.PluginInstanceName + "." + metric.TypeName + "." + metric.TypeInstanceName; return (routingKey); }
public void Aggregate(ref MetricValue metricValue) { // If rates are not stored then there is nothing to aggregate if (!_storeRates) { return; } IList <DataSource> dsl = DataSetCollection.Instance.GetDataSource(metricValue.TypeName); if (dsl == null || metricValue.Values.Length != dsl.Count) { return; } double now = Util.GetNow(); lock (_cacheLock) { CacheEntry cEntry; string key = metricValue.Key(); if (!(_cache.TryGetValue(key, out cEntry))) { cEntry = new CacheEntry(metricValue.DeepCopy()); for (int i = 0; i < metricValue.Values.Length; i++) { if (dsl[i].Type == DsType.Derive || dsl[i].Type == DsType.Absolute || dsl[i].Type == DsType.Counter) { metricValue.Values[i] = double.NaN; cEntry.MetricRate.Values[i] = double.NaN; } } cEntry.MetricRate.Timestamp = now; _cache[key] = cEntry; return; } for (int i = 0; i < metricValue.Values.Length; i++) { double rawValNew = metricValue.Values[i]; double rawValOld = cEntry.RawValues[i]; double rawValDiff = rawValNew - rawValOld; double timeDiff = cEntry.MetricRate.Timestamp - now; double rateNew = rawValDiff / timeDiff; switch (dsl[i].Type) { case DsType.Gauge: // no rates calculations are done, values are stored as-is for gauge cEntry.RawValues[i] = rawValNew; cEntry.MetricRate.Values[i] = rawValNew; break; case DsType.Absolute: // similar to gauge, except value will be divided by time diff cEntry.MetricRate.Values[i] = metricValue.Values[i] / timeDiff; cEntry.RawValues[i] = rawValNew; metricValue.Values[i] = cEntry.MetricRate.Values[i]; break; case DsType.Derive: cEntry.RawValues[i] = rawValNew; cEntry.MetricRate.Values[i] = rateNew; metricValue.Values[i] = rateNew; break; case DsType.Counter: // Counters are very simlar to derive except when counter wraps around if (rawValNew < rawValOld) { // counter has wrapped around cEntry.MetricRate.Values[i] = metricValue.Values[i] / timeDiff; cEntry.RawValues[i] = rawValNew; metricValue.Values[i] = cEntry.MetricRate.Values[i]; } else { cEntry.MetricRate.Values[i] = rateNew; cEntry.RawValues[i] = rawValNew; metricValue.Values[i] = rateNew; } break; } // range checks if (metricValue.Values[i] < dsl[i].Min) { metricValue.Values[i] = dsl[i].Min; cEntry.RawValues[i] = metricValue.Values[i]; } if (metricValue.Values[i] > dsl[i].Max) { metricValue.Values[i] = dsl[i].Max; cEntry.RawValues[i] = metricValue.Values[i]; } cEntry.MetricRate.Timestamp = now; _cache[key] = cEntry; } } }
public CacheEntry(MetricValue metricValue) { MetricRate = metricValue; RawValues = (double[]) metricValue.Values.Clone(); }
public IList <MetricValue> Read() { lock (_lock) { var res = new List <MetricValue>(); var removeList = new List <string>(); foreach (var pair in _metrics) { StatsdMetric metric = pair.Value; if (metric.NumUpdates <= 0 && ((_delCounter && metric.Type == StatsdMetric.StatsdType.StatsdCounter) || (_delTimer && metric.Type == StatsdMetric.StatsdType.StatsdTimer) || (_delGauge && metric.Type == StatsdMetric.StatsdType.StatsdGauge) || (_delSet && metric.Type == StatsdMetric.StatsdType.StatsdSet))) { removeList.Add(pair.Key); continue; } var metricVal = new MetricValue { HostName = _hostName, PluginName = "statsd", PluginInstanceName = "", TypeInstanceName = metric.Name, Values = new[] { metric.GetMetric() } }; switch (metric.Type) { case StatsdMetric.StatsdType.StatsdGauge: metricVal.TypeName = "gauge"; break; case StatsdMetric.StatsdType.StatsdTimer: metricVal.TypeName = "latency"; metricVal.TypeInstanceName += "-average"; break; case StatsdMetric.StatsdType.StatsdSet: metricVal.TypeName = "objects"; break; default: metricVal.TypeName = "derive"; break; } TimeSpan t = DateTime.UtcNow - new DateTime(1970, 1, 1); double epoch = t.TotalMilliseconds / 1000; metricVal.Epoch = Math.Round(epoch, 3); res.Add(metricVal); if (metric.Type == StatsdMetric.StatsdType.StatsdTimer) { if (_timerLower) { MetricValue lowerValue = metricVal.DeepCopy(); lowerValue.TypeInstanceName = metric.Name + "-lower"; lowerValue.Values[0] = metric.Lat.Min; res.Add(lowerValue); } if (_timerUpper) { MetricValue upperValue = metricVal.DeepCopy(); upperValue.TypeInstanceName = metric.Name + "-upper"; upperValue.Values[0] = metric.Lat.Max; res.Add(upperValue); } if (_timerSum) { MetricValue upperSum = metricVal.DeepCopy(); upperSum.TypeInstanceName = metric.Name + "-Sum"; upperSum.Values[0] = metric.Lat.Sum; res.Add(upperSum); } if (_timerCount) { MetricValue upperCount = metricVal.DeepCopy(); upperCount.TypeInstanceName = metric.Name + "-count"; upperCount.Values[0] = metric.Lat.Num; res.Add(upperCount); } Histogram histogram = metric.Lat.Histogram; if (_percentiles != null && _percentiles.Length > 0 && histogram != null) { foreach (float percentile in _percentiles) { double val = histogram.GetPercentile(percentile); MetricValue mv = metricVal.DeepCopy(); mv.TypeInstanceName = metric.Name + "-percentile-" + percentile; mv.Values[0] = val; res.Add(mv); } } } metric.Reset(); } Logger.Debug("Removing entries that were not updated:{0}", removeList.Count); foreach (string key in removeList) { _metrics.Remove(key); } return(res); } }
public MetricValue GetMetricValue(List<double> vals) { var metricValue = new MetricValue { HostName = s_hostName, PluginName = CollectdPlugin, PluginInstanceName = CollectdPluginInstance, TypeName = CollectdType, TypeInstanceName = CollectdTypeInstance, Values = vals.ToArray() }; TimeSpan t = DateTime.UtcNow - new DateTime(1970, 1, 1); double epoch = t.TotalMilliseconds / 1000; metricValue.Epoch = Math.Round(epoch, 3); return metricValue; }
public void GetIngestMetrics(MetricValue metric, out List<IngestMetric> metrics, out List<IngestSample> samples) { metrics = new List<IngestMetric>(); samples = new List<IngestSample>(); string metricId = metric.PluginName; if (metric.PluginInstanceName.Length > 0) metricId += "." + metric.PluginInstanceName.Replace(".", "_"); if (metric.TypeInstanceName.Length > 0) metricId += "." + metric.TypeInstanceName; metricId = Regex.Replace(metricId, "[ ]", "_"); // Keep spaces as underscores metricId = Regex.Replace(metricId, "[^a-zA-Z0-9\\._-]", ""); // Remove punctuation if (metric.Values.Length == 1) { // Simple case - just one metric in type metrics.Add(new IngestMetric(metricId, metric.FriendlyNames[0], metric.TypeName)); samples.Add(new IngestSample(metricId, (long)metric.Epoch * 1000, metric.Values[0])); } else if (metric.Values.Length > 1) { // Compound type with multiple metrics IList<DataSource> dsList = DataSetCollection.Instance.GetDataSource(metric.TypeName); if (dsList == null) { Logger.Debug("Invalid type : {0}, not found in types.db", metric.TypeName); } else { int ix = 0; foreach (DataSource ds in dsList) { // Include the Types.db suffix in the metric name metrics.Add(new IngestMetric(metricId + "." + ds.Name, metric.FriendlyNames[ix], metric.TypeName)); samples.Add(new IngestSample(metricId + "." + ds.Name, (long)metric.Epoch * 1000, metric.Values[ix])); ix++; } } } }