public void Add(
string context,
string name,
string field,
object value,
MetricTags metricTags,
IStatsDMetricStringSerializer serializer,
DateTime?timestamp)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name), "Name could not be null or whitespace");
}
if (string.IsNullOrWhiteSpace(field))
{
throw new ArgumentNullException(nameof(field), "Field could not be null or whitespace");
}
var tagsDictionary = metricTags.ToDictionary();
tagsDictionary.TryGetValue(AppMetricsConstants.Pack.MetricTagsTypeKey, out var metricType);
tagsDictionary.TryGetValue(StatsDFormatterConstants.ItemTagName, out var itemTag);
var key = BuildKeyName(context, name, metricType, itemTag, field);
var tags = tagsDictionary.Where(tag => !ExcludeTags.Contains(tag.Key)).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
var statsDMetricType = StatsDSyntax.FormatMetricType(metricType);
if (metricType == AppMetricsConstants.Pack.ApdexMetricTypeValue && field != "score")
{
statsDMetricType = StatsDSyntax.Count;
}
if (!StatsDSyntax.CanBeSampled(statsDMetricType) || metricType == AppMetricsConstants.Pack.MeterMetricTypeValue)
{
Points.Enqueue(new StatsDPoint(key, value, statsDMetricType, null, tags, serializer, timestamp));
return;
}
tagsDictionary.TryGetValue(StatsDFormatterConstants.SampleRateTagName, out var tagSampleRateStr);
if (!double.TryParse(tagSampleRateStr, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.InvariantInfo, out var tagSampleRate))
{
tagSampleRate = Options.DefaultSampleRate;
}
var sampler = _samplers.GetOrAdd(key, _ => new StatsDSampler());
if (sampler.ShouldSend(tagSampleRate))
{
Points.Enqueue(new StatsDPoint(key, value, statsDMetricType, tagSampleRate, tags, serializer, timestamp));
}
}
public MetricValueOptions EnsureContextLabelAndGlobalTags(MetricValueOptions options)
{
if (options.Context.IsMissing())
{
options.Context = _defaultContextLabel;
}
//TODO: AH - impure method called
options.Tags.With(_globalTags.ToDictionary());
return(options);
}
public void can_convert_to_dictionary_and_format_values()
{
var tags = new MetricTags(new[] { "key_1", "key_2" }, new[] { "value 1", "value 2" });
var dictionary = tags.ToDictionary(tagValue => tagValue.Replace(' ', '_'));
dictionary.Count.Should().Be(2);
dictionary.Keys.Should().Contain("key_1");
dictionary.Keys.Should().Contain("key_2");
dictionary.Values.Should().Contain("value_1");
dictionary.Values.Should().Contain("value_2");
}
public void can_convert_to_dictionary()
{
var tags = new MetricTags(new [] { "key_1", "key_2" }, new [] { "value 1", "value 2" });
var dictionary = tags.ToDictionary();
dictionary.Count.Should().Be(2);
dictionary.Keys.Should().Contain("key_1");
dictionary.Keys.Should().Contain("key_2");
dictionary.Values.Should().Contain("value 1");
dictionary.Values.Should().Contain("value 2");
}
/// <inheritdoc />
public void Write(string context, string name, string field, object value, MetricTags tags, DateTime timestamp)
{
var contextProperty = BuildContextProperty(context);
var nameProperty = BuildNameProperty(name);
var valueProperty = new LogEventProperty(field, new ScalarValue(value));
var tagsProperty = BuildTagsProperty(tags.ToDictionary());
var properties = new[] { contextProperty, nameProperty, valueProperty, tagsProperty };
var messageTemplate = GetMessageTemplate(tags);
var logEvent = new LogEvent(timestamp, _logEventLevel, null, _parser.Parse(messageTemplate), properties);
Log.Write(logEvent);
}
public void Pack(string name, object value, MetricTags tags)
{
var tagKeyValues = tags.ToDictionary(_metricTagValueFormatter);
_payload.Add(
new MetricsDocument
{
MeasurementType = tagKeyValues["mtype"],
MeasurementName = name,
Fields = new Dictionary <string, object> {
{ "value", value }
},
Tags = tagKeyValues
});
}
public void Add(
string context,
string name,
IEnumerable <string> columns,
IEnumerable <object> values,
MetricTags tags,
IStatsDMetricStringSerializer serializer,
DateTime?timestamp)
{
var fields = columns.Zip(values, (column, data) => new { column, data }).ToDictionary(pair => pair.column, pair => pair.data);
var tagsDictionary = tags.ToDictionary();
tagsDictionary.TryGetValue(AppMetricsConstants.Pack.MetricTagsTypeKey, out var metricType);
switch (metricType)
{
case "histogram":
Add(context, name, "value", fields["median"], tags, serializer, timestamp);
break;
case "meter":
Add(context, name, "value", fields["count.meter"], tags, serializer, timestamp);
break;
case "timer":
var value = fields["median"] switch
{
double d => Convert.ToInt64(d),
float f => Convert.ToInt64(f),
_ => (long)fields["median"]
};
var unit = tagsDictionary[AppMetricsConstants.Pack.MetricTagsUnitRateDurationKey].FromUnit();
value = unit.Convert(TimeUnit.Milliseconds, value);
Add(context, name, "value", value, tags, serializer, timestamp);
break;
default:
foreach (var kvp in fields)
{
Add(context, name, kvp.Key, kvp.Value, tags, serializer, timestamp);
}
break;
}
}
public void Pack(
string name,
IEnumerable <string> columns,
IEnumerable <object> values,
MetricTags tags)
{
var fields = columns.Zip(values, (column, data) => new { column, data }).ToDictionary(pair => pair.column, pair => pair.data);
var tagKeyValues = tags.ToDictionary(_metricTagValueFormatter);
_payload.Add(
new MetricsDocument
{
MeasurementType = tagKeyValues["mtype"],
MeasurementName = name,
Fields = fields,
Tags = tagKeyValues
});
}
public void RegisterProbes(ProbeContext context, string[] tagValues)
{
var tags = new MetricTags(Tags, tagValues);
foreach (var duration in context.Durations)
{
if (!DurationMapping.ContainsKey(duration.Name))
{
Logger.WarnFormat("Unsupported duration probe {0}", duration.Name);
continue;
}
var timer = DurationMapping[duration.Name];
duration.Register((ref DurationEvent @event) =>
Metrics.Instance.Measure.Timer.Time(timer, tags, Convert.ToInt64(@event.Duration.TotalMilliseconds)));
}
foreach (var signal in context.Signals)
{
if (!SignalMapping.ContainsKey(signal.Name))
{
Logger.WarnFormat("Unsupported signal probe {0}", signal.Name);
continue;
}
var meter = SignalMapping[signal.Name];
signal.Register((ref SignalEvent @event) =>
{
if (string.IsNullOrWhiteSpace(@event.MessageType))
{
Metrics.Instance.Measure.Meter.Mark(meter, tags);
}
else
{
var tagsWithMessageType = tags.ToDictionary();
tagsWithMessageType.Add("messagetype", @event.MessageType);
Metrics.Instance.Measure.Meter.Mark(meter, tagsWithMessageType.FromDictionary());
}
});
}
}
private string GetMessageTemplate(MetricTags metricTags, IEnumerable <string> columns = null)
{
columns = columns ?? Enumerable.Empty <string>();
var tags = metricTags.ToDictionary();
if (!tags.TryGetValue("mtype", out var mtype))
{
return(_messageTemplates.Fallback);
}
switch (mtype)
{
case "counter":
return(columns.Contains("percent")
? _messageTemplates.CounterItem
: _messageTemplates.Counter);
case "gauge":
return(_messageTemplates.Gauge);
case "histogram":
return(_messageTemplates.Histogram);
case "meter":
return(columns.Contains("percent")
? _messageTemplates.MeterItem
: _messageTemplates.Meter);
case "timer":
return(_messageTemplates.Timer);
default:
return(_messageTemplates.Fallback);
}
}
/// <inheritdoc />
public void Write(string context, string name, IEnumerable <string> columns, IEnumerable <object> values, MetricTags tags, DateTime timestamp)
{
var contextProperty = BuildContextProperty(context);
var nameProperty = BuildNameProperty(name);
var columnNames = columns as string[] ?? columns.ToArray();
var properties = new List <LogEventProperty> {
contextProperty, nameProperty
};
var fields = columnNames.Zip(values, (column, data) => new { column, data })
.ToDictionary(pair => pair.column, pair => pair.data);
properties.AddRange(fields.Select(field => new LogEventProperty(FixPropertyName(field.Key), new ScalarValue(field.Value))));
var metricTags = tags.ToDictionary();
AddItemProperty(columnNames, metricTags, properties);
var tagsProperty = BuildTagsProperty(metricTags);
properties.Add(tagsProperty);
var messageTemplate = GetMessageTemplate(tags, fields.Keys);
var logEvent = new LogEvent(timestamp, _logEventLevel, null, _parser.Parse(messageTemplate), properties);
Log.Write(logEvent);
}
private void Pack(string name, IEnumerable <string> columns, IEnumerable <object> values, MetricTags tags)
{
var fields = columns.Zip(values, (column, data) => new { column, data }).ToDictionary(pair => pair.column, pair => pair.data);
_payload.Add(new LineProtocolPoint(name, fields, tags.ToDictionary()));
}
private void Pack(string name, object value, MetricTags tags)
{
_payload.Add(new LineProtocolPoint(name, new Dictionary <string, object> {
{ "value", value }
}, tags.ToDictionary()));
}
