public CloudWatchLogMessage(string cameraUri, string logMessage, int cameraId = -1, MetricNames metricName = MetricNames.Unknown)
{
CameraUri = cameraUri;
LogMessage = logMessage;
CameraId = cameraId;
MetricName = metricName;
}
private void ValidateMetrics()
{
var validCollectionOptions = new[] {
"default",
"gcapi",
"stopwatch",
"BranchMispredictions",
"CacheMisses",
"InstructionRetired",
};
var reducedList = MetricNames.Distinct(StringComparer.OrdinalIgnoreCase);
var isSubset = !reducedList.Except(validCollectionOptions, StringComparer.OrdinalIgnoreCase).Any();
if (!isSubset)
{
var errorMessage = $"Valid collection metrics are: {string.Join("|", validCollectionOptions)}";
throw new InvalidOperationException(errorMessage);
}
MetricNames = reducedList.Count() > 0 ? new List <string>(reducedList) : new List <string> {
"stopwatch"
};
if (MetricNames.Any(n => !n.Equals("stopwatch")))
{
if (TraceEventSession.IsElevated() != true)
{
throw new UnauthorizedAccessException("The application is required to run as Administrator in order to capture kernel data");
}
}
}
public void MetricValuesAreCorrect()
{
var assertions = new List <Action>();
var enumVals = Enum.GetValues(typeof(CATSupportabilityCondition)).Cast <CATSupportabilityCondition>().ToList();
//Call each supportability metric a different number of times so ensure that they aggrgate
assertions.Add(() => Assert.AreEqual(enumVals.Count, _metrics.Count, $"Expected {enumVals.Count} metrics, Actual {_metrics.Count}"));
foreach (var enumVal in enumVals)
{
var countHits = (int)enumVal + 10;
for (var i = 0; i < countHits; i++)
{
_metricCounters.Record(enumVal);
}
var expectedName = MetricNames.GetSupportabilityCATConditionMetricName(enumVal);
//Ensure that we can find out metric
assertions.Add(() => Assert.IsNotNull(_metrics.FirstOrDefault(x => x.MetricName.Name == expectedName),
$"Unable to find metric '{expectedName}'"));
//Ensure its count matches the number of times the supportability metric was called
assertions.Add(() => Assert.AreEqual(countHits, _metrics.FirstOrDefault(x => x.MetricName.Name == MetricNames.GetSupportabilityCATConditionMetricName(enumVal)).Data.Value0));
}
//Act
_metricCounters.CollectMetrics();
//Assert
NrAssert.Multiple(assertions.ToArray());
}
public void TransformSample_ThreadpoolUsageStats_CreatesCorrectMetricValues()
{
const int countWorkerThreadsRemaining = 83;
const int countWorkerThreadsInUse = 17;
const int countCompletionThreadsRemaining = 180;
const int countCompletionThreadsInUse = 20;
var generatedMetrics = new Dictionary <string, MetricDataWireModel>();
Mock.Arrange(() => _metricAggregator
.Collect(Arg.IsAny <MetricWireModel>()))
.DoInstead <MetricWireModel>(m => generatedMetrics.Add(m.MetricName.Name, m.Data));
var sample = new ThreadpoolUsageStatsSample(countWorkerThreadsRemaining + countWorkerThreadsInUse, countWorkerThreadsRemaining, countCompletionThreadsRemaining + countCompletionThreadsInUse, countCompletionThreadsRemaining);
_threadStatsTransformer.Transform(sample);
NrAssert.Multiple(
() => Assert.AreEqual(4, generatedMetrics.Count),
() => MetricTestHelpers.CompareMetric(generatedMetrics, MetricNames.GetThreadpoolUsageStatsName(ThreadType.Worker, ThreadStatus.InUse), countWorkerThreadsInUse),
() => MetricTestHelpers.CompareMetric(generatedMetrics, MetricNames.GetThreadpoolUsageStatsName(ThreadType.Worker, ThreadStatus.Available), countWorkerThreadsRemaining),
() => MetricTestHelpers.CompareMetric(generatedMetrics, MetricNames.GetThreadpoolUsageStatsName(ThreadType.Completion, ThreadStatus.InUse), countCompletionThreadsInUse),
() => MetricTestHelpers.CompareMetric(generatedMetrics, MetricNames.GetThreadpoolUsageStatsName(ThreadType.Completion, ThreadStatus.Available), countCompletionThreadsRemaining)
);
}
public static void MetricNamesTest_GetGCMetricName()
{
var countGCSampleTypes = Enum.GetValues(typeof(GCSampleType)).Length;
var expectedMetricNames = new Dictionary <GCSampleType, string>
{
{ GCSampleType.HandlesCount, "GC/Handles" },
{ GCSampleType.InducedCount, "GC/Induced" },
{ GCSampleType.PercentTimeInGc, "GC/PercentTimeInGC" },
{ GCSampleType.Gen0CollectionCount, "GC/Gen0/Collections" },
{ GCSampleType.Gen0Size, "GC/Gen0/Size" },
{ GCSampleType.Gen0Promoted, "GC/Gen0/Promoted" },
{ GCSampleType.Gen1CollectionCount, "GC/Gen1/Collections" },
{ GCSampleType.Gen1Size, "GC/Gen1/Size" },
{ GCSampleType.Gen1Promoted, "GC/Gen1/Promoted" },
{ GCSampleType.Gen2CollectionCount, "GC/Gen2/Collections" },
{ GCSampleType.Gen2Size, "GC/Gen2/Size" },
{ GCSampleType.Gen2Survived, "GC/Gen2/Survived" },
{ GCSampleType.LOHSize, "GC/LOH/Size" },
{ GCSampleType.LOHSurvived, "GC/LOH/Survived" },
};
//Ensure that we have covered all sample types with our tests
Assert.AreEqual(countGCSampleTypes, expectedMetricNames.Count);
foreach (var sampleType in expectedMetricNames)
{
Assert.That(MetricNames.GetGCMetricName(sampleType.Key), Is.EqualTo(sampleType.Value));
}
}
public static void MetricNamesTest_ThreadPoolUsageStats()
{
Assert.That(MetricNames.GetThreadpoolUsageStatsName(Samplers.ThreadType.Worker, Samplers.ThreadStatus.Available), Is.EqualTo("Threadpool/Worker/Available"));
Assert.That(MetricNames.GetThreadpoolUsageStatsName(Samplers.ThreadType.Worker, Samplers.ThreadStatus.InUse), Is.EqualTo("Threadpool/Worker/InUse"));
Assert.That(MetricNames.GetThreadpoolUsageStatsName(Samplers.ThreadType.Completion, Samplers.ThreadStatus.Available), Is.EqualTo("Threadpool/Completion/Available"));
Assert.That(MetricNames.GetThreadpoolUsageStatsName(Samplers.ThreadType.Completion, Samplers.ThreadStatus.InUse), Is.EqualTo("Threadpool/Completion/InUse"));
}
public static void MetricNamesTest_AgentFeatureApiVersion()
{
Assert.That(MetricNames.GetSupportabilityAgentApi("method"), Is.EqualTo("Supportability/ApiInvocation/method"));
Assert.That(MetricNames.GetSupportabilityFeatureEnabled("feature"), Is.EqualTo("Supportability/FeatureEnabled/feature"));
Assert.That(MetricNames.GetSupportabilityAgentVersion("version"), Is.EqualTo("Supportability/AgentVersion/version"));
Assert.That(MetricNames.GetSupportabilityAgentVersionByHost("host", "version"), Is.EqualTo("Supportability/AgentVersion/host/version"));
Assert.That(MetricNames.GetSupportabilityLinuxOs(), Is.EqualTo("Supportability/OS/Linux"));
}
public void GetDotNetInvocation()
{
var metricName = MetricNames.GetDotNetInvocation("class", "method");
var sameMetricName = MetricNames.GetDotNetInvocation("class", "method");
Assert.AreEqual("DotNet/class/method", metricName.ToString());
Assert.AreEqual(metricName.GetHashCode(), sameMetricName.GetHashCode());
Assert.AreEqual(metricName, sameMetricName);
}
public override string GetTransactionTraceName()
{
// APM expects metric names to be used for external segment trace names
var name = CrossApplicationResponseData == null
? MetricNames.GetExternalHost(Uri.Host, "Stream", Method)
: MetricNames.GetExternalTransaction(Uri.Host, CrossApplicationResponseData.CrossProcessId, CrossApplicationResponseData.TransactionName);
return(name.ToString());
}
public static void MetricNamesTest_Utilization()
{
Assert.That(MetricNames.GetSupportabilityBootIdError(), Is.EqualTo("Supportability/utilization/boot_id/error"));
Assert.That(MetricNames.GetSupportabilityAwsUsabilityError(), Is.EqualTo("Supportability/utilization/aws/error"));
Assert.That(MetricNames.GetSupportabilityAzureUsabilityError(), Is.EqualTo("Supportability/utilization/azure/error"));
Assert.That(MetricNames.GetSupportabilityGcpUsabilityError(), Is.EqualTo("Supportability/utilization/gcp/error"));
Assert.That(MetricNames.GetSupportabilityPcfUsabilityError(), Is.EqualTo("Supportability/utilization/pcf/error"));
Assert.That(MetricNames.GetSupportabilityKubernetesUsabilityError(), Is.EqualTo("Supportability/utilization/kubernetes/error"));
}
public void BuildSupportabilityCountMetric_SuppliedCount()
{
const string MetricName = "WCFClient/BindingType/BasicHttpBinding";
var actualMetric = _metricBuilder.TryBuildSupportabilityCountMetric(MetricName, 2);
NrAssert.Multiple(
() => Assert.AreEqual(MetricNames.GetSupportabilityName(MetricName), actualMetric.MetricName.Name),
() => Assert.AreEqual(MetricDataWireModel.BuildCountData(2), actualMetric.Data)
);
}
public static void MetricNamesTest_AgentHealthEvent()
{
Assert.That(MetricNames.GetSupportabilityAgentHealthEvent(AgentHealthEvent.TransactionGarbageCollected, null),
Is.EqualTo("Supportability/TransactionGarbageCollected"));
Assert.That(MetricNames.GetSupportabilityAgentHealthEvent(AgentHealthEvent.TransactionGarbageCollected, "additional"),
Is.EqualTo("Supportability/TransactionGarbageCollected/additional"));
Assert.That(MetricNames.GetSupportabilityAgentHealthEvent(AgentHealthEvent.WrapperShutdown, null),
Is.EqualTo("Supportability/WrapperShutdown"));
Assert.That(MetricNames.GetSupportabilityAgentHealthEvent(AgentHealthEvent.WrapperShutdown, "additional"),
Is.EqualTo("Supportability/WrapperShutdown/additional"));
}
public void BuildThreadpoolThroughputStatsMetric()
{
const int RawValue = 3;
var throughputStatsType = Samplers.ThreadpoolThroughputStatsType.Started;
var actualMetric = _metricBuilder.TryBuildThreadpoolThroughputStatsMetric(throughputStatsType, RawValue);
NrAssert.Multiple(
() => Assert.AreEqual(MetricNames.GetThreadpoolThroughputStatsName(throughputStatsType), actualMetric.MetricName.Name),
() => Assert.AreEqual(MetricDataWireModel.BuildGaugeValue(RawValue), actualMetric.Data)
);
}
public void BuildGCPercentMetric()
{
const float RawPercentageValue = 0.8f;
var gcSampleType = Samplers.GCSampleType.PercentTimeInGc;
var actualMetric = _metricBuilder.TryBuildGCPercentMetric(gcSampleType, RawPercentageValue);
NrAssert.Multiple(
() => Assert.AreEqual(MetricNames.GetGCMetricName(gcSampleType), actualMetric.MetricName.Name),
() => Assert.AreEqual(MetricDataWireModel.BuildPercentageData(RawPercentageValue), actualMetric.Data)
);
}
public void BuildGCBytesMetric()
{
const long RawByteValue = 123456;
var gcSampleType = Samplers.GCSampleType.Gen0Size;
var actualMetric = _metricBuilder.TryBuildGCBytesMetric(gcSampleType, RawByteValue);
NrAssert.Multiple(
() => Assert.AreEqual(MetricNames.GetGCMetricName(gcSampleType), actualMetric.MetricName.Name),
() => Assert.AreEqual(MetricDataWireModel.BuildByteData(RawByteValue), actualMetric.Data)
);
}
public static void GetTransactionApdex_ReturnsExpectedMetricName()
{
var transaction = TestTransactions.CreateDefaultTransaction(true, null, null, null, null, null, "foo", "bar");
var immutableTransaction = transaction.ConvertToImmutableTransaction();
var transactionNameMaker = new TransactionMetricNameMaker(new MetricNameService());
var transactionApdex = MetricNames.GetTransactionApdex(transactionNameMaker.GetTransactionMetricName(immutableTransaction.TransactionName));
var expectedName = "Apdex/foo/bar";
Assert.AreEqual(expectedName, transactionApdex);
}
public void BuildGCCountMetric()
{
const int RawCountValue = 3;
var gcSampleType = Samplers.GCSampleType.Gen0CollectionCount;
var actualMetric = _metricBuilder.TryBuildGCCountMetric(gcSampleType, RawCountValue);
NrAssert.Multiple(
() => Assert.AreEqual(MetricNames.GetGCMetricName(gcSampleType), actualMetric.MetricName.Name),
() => Assert.AreEqual(MetricDataWireModel.BuildCountData(RawCountValue), actualMetric.Data)
);
}
public void BuildGCGaugeMetric()
{
const float RawValue = 3000f;
var gcSampleType = Samplers.GCSampleType.HandlesCount;
var actualMetric = _metricBuilder.TryBuildGCGaugeMetric(gcSampleType, RawValue);
NrAssert.Multiple(
() => Assert.AreEqual(MetricNames.GetGCMetricName(gcSampleType), actualMetric.MetricName.Name),
() => Assert.AreEqual(MetricDataWireModel.BuildGaugeValue(RawValue), actualMetric.Data)
);
}
public void BuildThreadpoolUsageStatsMetric()
{
const int RawValue = 3;
var threadType = Samplers.ThreadType.Worker;
var threadStatus = Samplers.ThreadStatus.Available;
var actualMetric = _metricBuilder.TryBuildThreadpoolUsageStatsMetric(threadType, threadStatus, RawValue);
NrAssert.Multiple(
() => Assert.AreEqual(MetricNames.GetThreadpoolUsageStatsName(threadType, threadStatus), actualMetric.MetricName.Name),
() => Assert.AreEqual(MetricDataWireModel.BuildGaugeValue(RawValue), actualMetric.Data)
);
}
private void CollectInfiniteTracingMetrics()
{
if (TryGetCount(_infiniteTracingSpanResponseError, out var errorCount))
{
ReportSupportabilityCountMetric(MetricNames.SupportabilityInfiniteTracingSpanResponseError, errorCount);
}
if (TryGetCount(_infiniteTracingSpanEventsDropped, out var spansDropped))
{
ReportSupportabilityCountMetric(MetricNames.SupportabilityInfiniteTracingSpanDropped, spansDropped);
}
if (TryGetCount(_infiniteTracingSpanEventsSeen, out var spanEventsSeen))
{
ReportSupportabilityCountMetric(MetricNames.SupportabilityInfiniteTracingSpanSeen, spanEventsSeen);
}
if (TryGetCount(_infiniteTracingSpanEventsSent, out var spanEventsSent) && TryGetCount(_infiniteTracingSpanBatchCount, out var spanBatchCount))
{
var minBatchSize = Interlocked.Exchange(ref _infiniteTracingSpanBatchSizeMin, long.MaxValue);
var maxBatchSize = Interlocked.Exchange(ref _infiniteTracingSpanBatchSizeMax, long.MinValue);
ReportSupportabilityCountMetric(MetricNames.SupportabilityInfiniteTracingSpanSent, spanEventsSent);
if (minBatchSize < long.MaxValue && maxBatchSize > long.MinValue)
{
ReportSupportabilitySummaryMetric(MetricNames.SupportabilityInfiniteTracingSpanSentBatchSize, spanEventsSent, spanBatchCount, minBatchSize, maxBatchSize);
}
}
if (TryGetCount(_infiniteTracingSpanEventsReceived, out var spanEventsReceived))
{
ReportSupportabilityCountMetric(MetricNames.SupportabilityInfiniteTracingSpanReceived, spanEventsReceived);
}
if (TryGetCount(_infiniteTracingSpanGrpcTimeout, out var timeouts))
{
ReportSupportabilityCountMetric(MetricNames.SupportabilityInfiniteTracingSpanGrpcTimeout, timeouts);
}
foreach (var errorCounterPair in _infiniteTracingSpanGrpcErrorCounters)
{
if (TryGetCount(errorCounterPair.Value, out var grpcErrorCount))
{
var metricName = MetricNames.SupportabilityInfiniteTracingSpanGrpcError(errorCounterPair.Key);
ReportSupportabilityCountMetric(metricName, grpcErrorCount);
}
}
}
public static void MetricNamesTest_CAT()
{
var testDic = new Dictionary <CATSupportabilityCondition, string>
{
{ CATSupportabilityCondition.Request_Create_Success, "Supportability/CrossApplicationTracing/Request/Create/Success" },
{ CATSupportabilityCondition.Request_Create_Failure, "Supportability/CrossApplicationTracing/Request/Create/Exception" },
{ CATSupportabilityCondition.Request_Create_Failure_XProcID, "Supportability/CrossApplicationTracing/Request/Create/Exception/CrossProcessID" },
{ CATSupportabilityCondition.Request_Accept_Success, "Supportability/CrossApplicationTracing/Request/Accept/Success" },
{ CATSupportabilityCondition.Request_Accept_Failure, "Supportability/CrossApplicationTracing/Request/Accept/Exception" },
{ CATSupportabilityCondition.Request_Accept_Failure_NotTrusted, "Supportability/CrossApplicationTracing/Request/Accept/Ignored/NotTrusted" },
{ CATSupportabilityCondition.Request_Accept_Failure_Decode, "Supportability/CrossApplicationTracing/Request/Accept/Ignored/UnableToDecode" },
{ CATSupportabilityCondition.Request_Accept_Multiple, "Supportability/CrossApplicationTracing/Request/Accept/Warning/MultipleAttempts" },
{ CATSupportabilityCondition.Response_Create_Success, "Supportability/CrossApplicationTracing/Response/Create/Success" },
{ CATSupportabilityCondition.Response_Create_Failure, "Supportability/CrossApplicationTracing/Response/Create/Exception" },
{ CATSupportabilityCondition.Response_Create_Failure_XProcID, "Supportability/CrossApplicationTracing/Response/Create/Exception/CrossProcessID" },
{ CATSupportabilityCondition.Response_Accept_Success, "Supportability/CrossApplicationTracing/Response/Accept/Success" },
{ CATSupportabilityCondition.Response_Accept_Failure, "Supportability/CrossApplicationTracing/Response/Accept/Exception" },
{ CATSupportabilityCondition.Response_Accept_MultipleResponses, "Supportability/CrossApplicationTracing/Response/Accept/Ignored/MultipleAttempts" }
};
var assertions = new List <Action>();
foreach (var d in testDic)
{
var catCond = d;
assertions.Add(() => Assert.AreEqual(catCond.Value, MetricNames.GetSupportabilityCATConditionMetricName(catCond.Key), $"Expected '{catCond.Value}', actual '{MetricNames.GetSupportabilityCATConditionMetricName(catCond.Key)}'"));
}
var countTests = testDic.Count;
var countEnumValues = Enum.GetValues(typeof(CATSupportabilityCondition)).Length;
assertions.Add(() => Assert.True(countTests == countEnumValues, $"Test Coverage - there are {countEnumValues - countTests} enums missing from this test"));
NrAssert.Multiple(assertions.ToArray());
}
public void TransformSample_ThreadpoolThroughputStats_CreatesCorrectMetricValues()
{
const int countThreadRequestsQueued = 5;
const int countThreadRequestsDequeued = 7;
const int countThreadRequestQueueLength = 19;
var generatedMetrics = new Dictionary <string, MetricDataWireModel>();
Mock.Arrange(() => _metricAggregator
.Collect(Arg.IsAny <MetricWireModel>()))
.DoInstead <MetricWireModel>(m => generatedMetrics.Add(m.MetricName.Name, m.Data));
var sample = new ThreadpoolThroughputEventsSample(countThreadRequestsQueued, countThreadRequestsDequeued, countThreadRequestQueueLength);
_threadStatsTransformer.Transform(sample);
NrAssert.Multiple(
() => Assert.AreEqual(3, generatedMetrics.Count),
() => MetricTestHelpers.CompareMetric(generatedMetrics, MetricNames.GetThreadpoolThroughputStatsName(ThreadpoolThroughputStatsType.Requested), countThreadRequestsQueued),
() => MetricTestHelpers.CompareMetric(generatedMetrics, MetricNames.GetThreadpoolThroughputStatsName(ThreadpoolThroughputStatsType.Started), countThreadRequestsDequeued),
() => MetricTestHelpers.CompareMetric(generatedMetrics, MetricNames.GetThreadpoolThroughputStatsName(ThreadpoolThroughputStatsType.QueueLength), countThreadRequestQueueLength)
);
}
private void Transform(ImmutableTransaction immutableTransaction, TransactionMetricName transactionMetricName)
{
if (!immutableTransaction.Segments.Any())
{
throw new ArgumentException("Transaction does not have any segments");
}
FinishSegments(immutableTransaction.Segments);
TryGenerateExplainPlans(immutableTransaction.Segments);
var totalTime = GetTotalExclusiveTime(immutableTransaction.Segments);
var transactionApdexMetricName = MetricNames.GetTransactionApdex(transactionMetricName);
var apdexT = GetApdexT(immutableTransaction, transactionMetricName.PrefixedName);
var txStats = new TransactionMetricStatsCollection(transactionMetricName);
GenerateAndCollectSqlTrace(immutableTransaction, transactionMetricName, txStats);
GenerateAndCollectMetrics(immutableTransaction, apdexT, transactionApdexMetricName, totalTime, txStats);
// defer the creation of attributes until something asks for them.
Func <IAttributeValueCollection> attributes = () => _transactionAttributeMaker.GetAttributes(immutableTransaction, transactionMetricName, apdexT, totalTime, txStats);
attributes = attributes.Memoize();
// Must generate errors first so other wire models get attribute updates
if (immutableTransaction.TransactionMetadata.ReadOnlyTransactionErrorState.HasError)
{
GenerateAndCollectErrorEventTracesAndEvents(immutableTransaction, attributes.Invoke(), transactionMetricName);
}
GenerateAndCollectTransactionEvent(immutableTransaction, attributes);
GenerateAndCollectTransactionTrace(immutableTransaction, transactionMetricName, attributes);
GenerateAndCollectSpanEvents(immutableTransaction, transactionMetricName.PrefixedName, attributes);
}
public string MetricNamesTest_SupportabilityInfiniteTracingSpanGrpcError(StatusCode statusCode)
{
return(MetricNames.SupportabilityInfiniteTracingSpanGrpcError(EnumNameCache <StatusCode> .GetNameToUpperSnakeCase(statusCode)));
}
public override string GetTransactionTraceName()
{
return(MetricNames.GetMessageBroker(DestinationType, Action, Vendor, Destination).ToString());
}
public override string GetTransactionTraceName()
{
var name = Model == null?DatastoreVendorName.GetDatastoreOperation(Operation) : MetricNames.GetDatastoreStatement(DatastoreVendorName, Model, Operation);
return(name.ToString());
}
public override string GetTransactionTraceName()
{
return(MetricNames.GetDotNetInvocation(Type, Method).ToString());
}
public void GetDatastoreInstance()
{
Assert.AreEqual("Datastore/instance/MSSQL/compy64/808", MetricNames.GetDatastoreInstance(DatastoreVendor.MSSQL, "compy64", "808").ToString());
}
public void GetDatastoreStatement()
{
Assert.AreEqual("Datastore/statement/MySQL/users/select", MetricNames.GetDatastoreStatement(DatastoreVendor.MySQL, "users", "select").ToString());
}
public static void MetricNamesTest_GetSupportabilityName()
{
const string metricName = "WCFClient/BindingType/BasicHttpBinding";
Assert.That(MetricNames.GetSupportabilityName(metricName), Is.EqualTo($"Supportability/{metricName}"));
}
