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}")); }