// nothing to do as we are not buffering data // Load the configurations for a conf type private void LoadGangliaConf(AbstractGangliaSink.GangliaConfType gtype) { string[] propertyarr = conf.GetStringArray(gtype.ToString()); if (propertyarr != null && propertyarr.Length > 0) { foreach (string metricNValue in propertyarr) { string[] metricNValueArr = metricNValue.Split(Equal); if (metricNValueArr.Length != 2 || metricNValueArr[0].Length == 0) { Log.Error("Invalid propertylist for " + gtype.ToString()); } string metricName = metricNValueArr[0].Trim(); string metricValue = metricNValueArr[1].Trim(); GangliaConf gconf = gangliaConfMap[metricName]; if (gconf == null) { gconf = new GangliaConf(); gangliaConfMap[metricName] = gconf; } switch (gtype) { case AbstractGangliaSink.GangliaConfType.units: { gconf.SetUnits(metricValue); break; } case AbstractGangliaSink.GangliaConfType.dmax: { gconf.SetDmax(System.Convert.ToInt32(metricValue)); break; } case AbstractGangliaSink.GangliaConfType.tmax: { gconf.SetTmax(System.Convert.ToInt32(metricValue)); break; } case AbstractGangliaSink.GangliaConfType.slope: { gconf.SetSlope(AbstractGangliaSink.GangliaSlope.ValueOf(metricValue)); break; } } } } }
/// <summary>The method sends metrics to Ganglia servers.</summary> /// <remarks> /// The method sends metrics to Ganglia servers. The method has been taken from /// org.apache.hadoop.metrics.ganglia.GangliaContext30 with minimal changes in /// order to keep it in sync. /// </remarks> /// <param name="groupName">The group name of the metric</param> /// <param name="name">The metric name</param> /// <param name="type">The type of the metric</param> /// <param name="value">The value of the metric</param> /// <param name="gConf">The GangliaConf for this metric</param> /// <param name="gSlope">The slope for this metric</param> /// <exception cref="System.IO.IOException"/> protected internal virtual void EmitMetric(string groupName, string name, string type, string value, GangliaConf gConf, AbstractGangliaSink.GangliaSlope gSlope) { if (name == null) { Log.Warn("Metric was emitted with no name."); return; } else { if (value == null) { Log.Warn("Metric name " + name + " was emitted with a null value."); return; } else { if (type == null) { Log.Warn("Metric name " + name + ", value " + value + " has no type."); return; } } } if (Log.IsDebugEnabled()) { Log.Debug("Emitting metric " + name + ", type " + type + ", value " + value + ", slope " + gSlope.ToString() + " from hostname " + GetHostName()); } Xdr_int(0); // metric_user_defined Xdr_string(type); Xdr_string(name); Xdr_string(value); Xdr_string(gConf.GetUnits()); Xdr_int((int)(gSlope)); Xdr_int(gConf.GetTmax()); Xdr_int(gConf.GetDmax()); // send the metric to Ganglia hosts EmitToGangliaHosts(); }
// Calculate the slope from properties and metric private AbstractGangliaSink.GangliaSlope CalculateSlope(GangliaConf gConf, AbstractGangliaSink.GangliaSlope slopeFromMetric) { if (gConf.GetSlope() != null) { // if slope has been specified in properties, use that return(gConf.GetSlope()); } else { if (slopeFromMetric != null) { // slope not specified in properties, use derived from Metric return(slopeFromMetric); } else { return(DefaultSlope); } } }
public override void PutMetrics(MetricsRecord record) { // The method handles both cases whether Ganglia support dense publish // of metrics of sparse (only on change) publish of metrics try { string recordName = record.Name(); string contextName = record.Context(); StringBuilder sb = new StringBuilder(); sb.Append(contextName); sb.Append('.'); sb.Append(recordName); AppendPrefix(record, sb); string groupName = sb.ToString(); sb.Append('.'); int sbBaseLen = sb.Length; string type = null; AbstractGangliaSink.GangliaSlope slopeFromMetric = null; AbstractGangliaSink.GangliaSlope calculatedSlope = null; MetricsCache.Record cachedMetrics = null; ResetBuffer(); // reset the buffer to the beginning if (!IsSupportSparseMetrics()) { // for sending dense metrics, update metrics cache // and get the updated data cachedMetrics = metricsCache.Update(record); if (cachedMetrics != null && cachedMetrics.MetricsEntrySet() != null) { foreach (KeyValuePair <string, AbstractMetric> entry in cachedMetrics.MetricsEntrySet ()) { AbstractMetric metric = entry.Value; sb.Append(metric.Name()); string name = sb.ToString(); // visit the metric to identify the Ganglia type and // slope metric.Visit(gangliaMetricVisitor); type = gangliaMetricVisitor.GetType(); slopeFromMetric = gangliaMetricVisitor.GetSlope(); GangliaConf gConf = GetGangliaConfForMetric(name); calculatedSlope = CalculateSlope(gConf, slopeFromMetric); // send metric to Ganglia EmitMetric(groupName, name, type, metric.Value().ToString(), gConf, calculatedSlope ); // reset the length of the buffer for next iteration sb.Length = sbBaseLen; } } } else { // we support sparse updates ICollection <AbstractMetric> metrics = (ICollection <AbstractMetric>)record.Metrics (); if (metrics.Count > 0) { // we got metrics. so send the latest foreach (AbstractMetric metric in record.Metrics()) { sb.Append(metric.Name()); string name = sb.ToString(); // visit the metric to identify the Ganglia type and // slope metric.Visit(gangliaMetricVisitor); type = gangliaMetricVisitor.GetType(); slopeFromMetric = gangliaMetricVisitor.GetSlope(); GangliaConf gConf = GetGangliaConfForMetric(name); calculatedSlope = CalculateSlope(gConf, slopeFromMetric); // send metric to Ganglia EmitMetric(groupName, name, type, metric.Value().ToString(), gConf, calculatedSlope ); // reset the length of the buffer for next iteration sb.Length = sbBaseLen; } } } } catch (IOException io) { throw new MetricsException("Failed to putMetrics", io); } }
/// <summary>The method sends metrics to Ganglia servers.</summary> /// <remarks> /// The method sends metrics to Ganglia servers. The method has been taken from /// org.apache.hadoop.metrics.ganglia.GangliaContext31 with minimal changes in /// order to keep it in sync. /// </remarks> /// <param name="groupName">The group name of the metric</param> /// <param name="name">The metric name</param> /// <param name="type">The type of the metric</param> /// <param name="value">The value of the metric</param> /// <param name="gConf">The GangliaConf for this metric</param> /// <param name="gSlope">The slope for this metric</param> /// <exception cref="System.IO.IOException"/> protected internal override void EmitMetric(string groupName, string name, string type, string value, GangliaConf gConf, AbstractGangliaSink.GangliaSlope gSlope) { if (name == null) { Log.Warn("Metric was emitted with no name."); return; } else { if (value == null) { Log.Warn("Metric name " + name + " was emitted with a null value."); return; } else { if (type == null) { Log.Warn("Metric name " + name + ", value " + value + " has no type."); return; } } } if (Log.IsDebugEnabled()) { Log.Debug("Emitting metric " + name + ", type " + type + ", value " + value + ", slope " + gSlope.ToString() + " from hostname " + GetHostName()); } // The following XDR recipe was done through a careful reading of // gm_protocol.x in Ganglia 3.1 and carefully examining the output of // the gmetric utility with strace. // First we send out a metadata message Xdr_int(128); // metric_id = metadata_msg Xdr_string(GetHostName()); // hostname Xdr_string(name); // metric name Xdr_int(0); // spoof = False Xdr_string(type); // metric type Xdr_string(name); // metric name Xdr_string(gConf.GetUnits()); // units Xdr_int((int)(gSlope)); // slope Xdr_int(gConf.GetTmax()); // tmax, the maximum time between metrics Xdr_int(gConf.GetDmax()); // dmax, the maximum data value Xdr_int(1); /*Num of the entries in extra_value field for * Ganglia 3.1.x*/ Xdr_string("GROUP"); /*Group attribute*/ Xdr_string(groupName); /*Group value*/ // send the metric to Ganglia hosts EmitToGangliaHosts(); // Now we send out a message with the actual value. // Technically, we only need to send out the metadata message once for // each metric, but I don't want to have to record which metrics we did and // did not send. Xdr_int(133); // we are sending a string value Xdr_string(GetHostName()); // hostName Xdr_string(name); // metric name Xdr_int(0); // spoof = False Xdr_string("%s"); // format field Xdr_string(value); // metric value // send the metric to Ganglia hosts EmitToGangliaHosts(); }
/// <summary>Lookup GangliaConf from cache.</summary> /// <remarks>Lookup GangliaConf from cache. If not found, return default values</remarks> /// <param name="metricName"/> /// <returns>looked up GangliaConf</returns> protected internal virtual GangliaConf GetGangliaConfForMetric(string metricName) { GangliaConf gconf = gangliaConfMap[metricName]; return(gconf != null ? gconf : DefaultGangliaConf); }