public void GetErrorEvent_InTransaction_IfStatusCodeIs404_ContainsCorrectAttributes()
{
var transaction = BuildTestTransaction(statusCode: 404, uri: "http://www.newrelic.com/test?param=value", isSynthetics: false, isCAT: false, referrerUri: "http://referrer.uri");
var immutableTransaction = transaction.ConvertToImmutableTransaction();
var errorData = transaction.TransactionMetadata.TransactionErrorState.ErrorData;
var transactionMetricName = _transactionMetricNameMaker.GetTransactionMetricName(immutableTransaction.TransactionName);
var txStats = new TransactionMetricStatsCollection(transactionMetricName);
var attributes = _transactionAttributeMaker.GetAttributes(immutableTransaction, transactionMetricName, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(15), txStats);
var errorEvent = _errorEventMaker.GetErrorEvent(immutableTransaction, attributes);
var intrinsicAttributes = errorEvent.IntrinsicAttributes().Keys.ToArray();
var agentAttributes = errorEvent.AgentAttributes().Keys.ToArray();
var userAttributes = errorEvent.UserAttributes().Keys.ToArray();
NrAssert.Multiple(
() => Assert.AreEqual(false, errorEvent.IsSynthetics),
() => Assert.AreEqual(7, agentAttributes.Length),
() => Assert.AreEqual(7, intrinsicAttributes.Length),
() => Assert.AreEqual(0, userAttributes.Length),
() => Assert.Contains("queue_wait_time_ms", agentAttributes),
() => Assert.Contains("response.status", agentAttributes),
() => Assert.Contains("http.statusCode", agentAttributes),
() => Assert.Contains("original_url", agentAttributes),
() => Assert.Contains("request.uri", agentAttributes),
() => Assert.Contains("request.referer", agentAttributes),
() => Assert.Contains("host.displayName", agentAttributes),
() => Assert.Contains("duration", intrinsicAttributes),
() => Assert.Contains("error.class", intrinsicAttributes),
() => Assert.Contains("error.message", intrinsicAttributes),
() => Assert.Contains("queueDuration", intrinsicAttributes),
() => Assert.Contains("transactionName", intrinsicAttributes),
() => Assert.Contains("timestamp", intrinsicAttributes),
() => Assert.Contains("type", intrinsicAttributes)
);
}
public void Test()
{
var expectedMetrics = new List <Assertions.ExpectedMetric>()
{
new Assertions.ExpectedMetric {
metricName = "Datastore/all", callCount = 3
},
new Assertions.ExpectedMetric {
metricName = "Datastore/Redis/all", callCount = 3
},
new Assertions.ExpectedMetric {
metricName = "Datastore/operation/Redis/" + ServiceStackRedisCommands.SaveAsync, callCount = 1
},
new Assertions.ExpectedMetric {
metricName = "Datastore/operation/Redis/" + ServiceStackRedisCommands.SaveAsync, metricScope = "WebTransaction/MVC/RedisController/Get", callCount = 1
},
new Assertions.ExpectedMetric {
metricName = "Datastore/operation/Redis/" + ServiceStackRedisCommands.Shutdown, callCount = 1
},
new Assertions.ExpectedMetric {
metricName = "Datastore/operation/Redis/" + ServiceStackRedisCommands.Shutdown, metricScope = "WebTransaction/MVC/RedisController/Get", callCount = 1
},
new Assertions.ExpectedMetric {
metricName = "Datastore/operation/Redis/" + ServiceStackRedisCommands.RewriteAppendOnlyFileAsync, callCount = 1
},
new Assertions.ExpectedMetric {
metricName = "Datastore/operation/Redis/" + ServiceStackRedisCommands.RewriteAppendOnlyFileAsync, metricScope = "WebTransaction/MVC/RedisController/Get", callCount = 1
},
};
var actualMetrics = _fixture.AgentLog.GetMetrics().ToList();
NrAssert.Multiple
(
() => Assertions.MetricsExist(expectedMetrics, actualMetrics)
);
}
public void Test()
{
var expectedMetrics = new List <Assertions.ExpectedMetric>
{
new Assertions.ExpectedMetric {
metricName = @"OtherTransaction/Custom/MyCustomMetricName", callCount = 1
},
new Assertions.ExpectedMetric {
metricName = @"Custom/MyCustomMetricName", callCount = 1
},
new Assertions.ExpectedMetric {
metricName = @"Custom/MyCustomMetricName", metricScope = "OtherTransaction/Custom/MyCustomMetricName", callCount = 1
}
};
var expectedTransactionTraceSegments = new List <string>
{
@"MyCustomMetricName",
};
var metrics = _fixture.AgentLog.GetMetrics().ToList();
var transactionSample = _fixture.AgentLog
.GetTransactionSamples()
.FirstOrDefault(sample => sample.Path == @"OtherTransaction/Custom/MyCustomMetricName");
var transactionEvent = _fixture.AgentLog.GetTransactionEvents()
.FirstOrDefault();
NrAssert.Multiple(
() => Assert.NotNull(transactionSample),
() => Assert.NotNull(transactionEvent)
);
NrAssert.Multiple
(
() => Assertions.MetricsExist(expectedMetrics, metrics),
() => Assertions.TransactionTraceSegmentsExist(expectedTransactionTraceSegments, transactionSample)
);
}
public void Test()
{
var expectedMetrics = new List <Assertions.ExpectedMetric>
{
// Most application-level metrics (which come from async calls) are suppressed by the existence of the legacy asp pipeline
new Assertions.ExpectedMetric {
metricName = @"DotNet/PostgresController/PostgresAsync", callCount = 1
},
new Assertions.ExpectedMetric {
metricName = @"DotNet/Npgsql.NpgsqlConnection/Open", callCount = 1
},
new Assertions.ExpectedMetric {
metricName = @"WebTransaction/MVC/PostgresController/PostgresAsync", callCount = 1
},
};
var unexpectedMetrics = new List <Assertions.ExpectedMetric>
{
// These should be suppressed by the existence of the legacy asp pipeline
new Assertions.ExpectedMetric {
metricName = @"Datastore/statement/Postgres/teammembers/select", callCount = 1
},
new Assertions.ExpectedMetric {
metricName = @"Datastore/statement/Postgres/teammembers/select", callCount = 1, metricScope = "WebTransaction/MVC/PostgresController/PostgresAsync"
},
};
var metrics = _fixture.AgentLog.GetMetrics().ToList();
NrAssert.Multiple
(
() => Assertions.MetricsExist(expectedMetrics, metrics),
() => Assertions.MetricsDoNotExist(unexpectedMetrics, metrics)
);
var httpClientSuppressedRegex =
@".* The method (.+) in class (.+) from assembly (.+) will not be instrumented. (.*)";
Assert.NotNull(_fixture.AgentLog.TryGetLogLine(httpClientSuppressedRegex));
}
public void SimpleTransaction_CreatesDatastoreTransactionAndExplainPlan()
{
var sqlCommand = new SqlCommand();
var commandText = "SELECT * FROM Table1";
sqlCommand.CommandText = commandText;
_compositeTestAgent.LocalConfiguration.transactionTracer.explainEnabled = true;
_compositeTestAgent.LocalConfiguration.transactionTracer.explainThreshold = 0; // Config to run explain plans on queries with any nonzero duration
_compositeTestAgent.PushConfiguration();
var tx = _agent.CreateTransaction(
isWeb: true,
category: EnumNameCache <WebTransactionType> .GetName(WebTransactionType.Action),
transactionDisplayName: "name",
doNotTrackAsUnitOfWork: true);
var segment = _agent.StartDatastoreRequestSegmentOrThrow("SELECT", DatastoreVendor.MSSQL, "Table1", commandText);
_agent.EnableExplainPlans(segment, () => AllocateResources(sqlCommand), GenerateExplainPlan, () => new VendorExplainValidationResult(true));
segment.End();
tx.End();
_compositeTestAgent.Harvest();
var transactionTrace = _compositeTestAgent.TransactionTraces.First();
var sqlTrace = _compositeTestAgent.SqlTraces.First();
var explainPlan = (ExplainPlanWireModel)sqlTrace.ParameterData["explain_plan"];
var explainPlanData = explainPlan.ExplainPlanDatas.First().ToList();
var transactionSegments = transactionTrace.TransactionTraceData.RootSegment.Children;
var transactionExplainPlan = (ExplainPlanWireModel)transactionSegments.First().Children.First().Parameters.Values.First();
NrAssert.Multiple(
() => Assert.IsNotNull(explainPlan),
() => Assert.AreEqual(commandText, explainPlanData[0].ToString()),
() => Assert.AreEqual("SELECT", explainPlanData[1].ToString()),
() => Assert.IsTrue(sqlTrace.ParameterData.ContainsKey("explain_plan")),
() => Assert.AreEqual(sqlTrace.ParameterData.Values.First(), explainPlan),
() => Assert.AreEqual(transactionExplainPlan.ExplainPlanDatas, explainPlan.ExplainPlanDatas),
() => Assert.AreEqual(transactionExplainPlan.ExplainPlanHeaders, explainPlan.ExplainPlanHeaders)
);
}
public void SupportabilityMetric_Request_Accept_Failure_Exception()
{
//Collect the different metric counts in a dictionary that we can use
var conditionCounts = new Dictionary <CATSupportabilityCondition, int>();
Mock.Arrange(() => _catMetricCounters.Record(Arg.IsAny <CATSupportabilityCondition>()))
.DoInstead <CATSupportabilityCondition>((cond) =>
{
if (cond == CATSupportabilityCondition.Request_Accept_Success)
{
throw new Exception("Test Exception");
}
if (!conditionCounts.ContainsKey(cond))
{
conditionCounts.Add(cond, 0);
}
conditionCounts[cond]++;
});
var trx = _agent.CreateTransaction(
isWeb: true,
category: EnumNameCache <WebTransactionType> .GetName(WebTransactionType.Action),
transactionDisplayName: "name",
doNotTrackAsUnitOfWork: true);
var requestHeaders = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>(NewRelicIdHttpHeader, _crossProcessIDEncoded),
new KeyValuePair <string, string>(TransactionDataHttpHeader, _reqDataEncoded)
};
_agent.CurrentTransaction.AcceptDistributedTraceHeaders(requestHeaders, HeaderFunctions.GetHeaders, TransportType.HTTP);
NrAssert.Multiple
(
() => TestExistenceOfConditions(conditionCounts, CATSupportabilityCondition.Request_Accept_Failure),
() => TestConditionValue(conditionCounts, CATSupportabilityCondition.Request_Accept_Failure, 1)
);
}
public void Test()
{
var expectedAttributes = new List <string>()
{
"parent.type",
"parent.app",
"parent.account",
"parent.transportType",
"parent.transportDuration",
"guid",
"traceId",
"priority",
"sampled"
};
var transactionEventExpectedAttributes = new List <string>(expectedAttributes)
{
"parentId"
};
var transactionEvent = _fixture.AgentLog.GetTransactionEvents().FirstOrDefault();
var errorEvent = _fixture.AgentLog.GetErrorEvents().First().Events.First();
var errorTrace = _fixture.AgentLog.GetErrorTraces().FirstOrDefault();
var transactionSample = _fixture.AgentLog.GetTransactionSamples()
.FirstOrDefault(sample => sample.Path == @"WebTransaction/MVC/DistributedTracingController/ReceivePayload");
NrAssert.Multiple(
() => Assertions.TransactionEventHasAttributes(transactionEventExpectedAttributes, TransactionEventAttributeType.Intrinsic, transactionEvent),
() => Assertions.ErrorEventHasAttributes(expectedAttributes, EventAttributeType.Intrinsic, errorEvent),
() => Assertions.ErrorTraceHasAttributes(expectedAttributes, ErrorTraceAttributeType.Intrinsic, errorTrace),
() => Assertions.TransactionTraceHasAttributes(expectedAttributes, TransactionTraceAttributeType.Intrinsic, transactionSample)
);
var parentIdKey = "parentId";
var expectedParentId = "27856f70d3d314b7";
var transactionEventParentId = transactionEvent.IntrinsicAttributes[parentIdKey];
Assert.Equal(expectedParentId, transactionEventParentId);
}
public void Test()
{
var metrics = _fixture.AgentLog.GetMetrics().ToList();
Assert.NotNull(metrics);
NrAssert.Multiple(
() => Assertions.MetricsExist(_generalMetrics, metrics),
() => Assert.Empty(_fixture.AgentLog.GetErrorTraces()),
() => Assert.Empty(_fixture.AgentLog.GetErrorEvents())
);
NrAssert.Multiple
(
() => Assertions.MetricsExist(_ioBoundNoSpecialAsyncMetrics, metrics),
() => Assertions.MetricsExist(_ioBoundConfigureAwaitFalseAsyncMetrics, metrics),
() => Assertions.MetricsExist(_cpuBoundTasksAsyncMetrics, metrics)
);
NrAssert.Multiple
(
() => Assertions.MetricsExist(_manualTaskRunBlockedMetrics, metrics),
() => Assertions.MetricsExist(_manualTaskFactoryStartNewMetrics, metrics),
() => Assertions.MetricsExist(_manualNewThreadStartBlocked, metrics)
);
var transactionSample = _fixture.AgentLog.GetTransactionSamples().FirstOrDefault(sample => sample.Path == "WebTransaction/WebAPI/AsyncAwait/CpuBoundTasksAsync");
var expectedTransactionTraceSegments = new List <string>
{
@"DotNet/AsyncAwait/CpuBoundTasksAsync",
@"TaskRunBackgroundMethod",
@"TaskFactoryStartNewBackgroundMethod"
};
NrAssert.Multiple(
() => Assert.NotNull(transactionSample),
() => Assertions.TransactionTraceSegmentsExist(expectedTransactionTraceSegments, transactionSample)
);
}
public void Test()
{
var catResponseHeader = _responseHeaders.GetValues(@"X-NewRelic-App-Data")?.FirstOrDefault();
Assert.NotNull(catResponseHeader);
var catResponseData = HeaderEncoder.DecodeAndDeserialize <CrossApplicationResponseData>(catResponseHeader, HeaderEncoder.IntegrationTestEncodingKey);
var transactionSample = _fixture.AgentLog.TryGetTransactionSample("WebTransaction/MVC/DefaultController/Index");
var transactionEvent = _fixture.AgentLog.TryGetTransactionEvent("WebTransaction/MVC/DefaultController/Index");
var metrics = _fixture.AgentLog.GetMetrics();
NrAssert.Multiple
(
() => Assert.NotNull(transactionSample),
() => Assert.NotNull(transactionEvent)
);
NrAssert.Multiple
(
() => Assert.Equal(_fixture.AgentLog.GetCrossProcessId(), catResponseData.CrossProcessId),
() => Assert.Equal("WebTransaction/MVC/DefaultController/Index", catResponseData.TransactionName),
() => Assert.True(catResponseData.QueueTimeInSeconds >= 0),
() => Assert.True(catResponseData.ResponseTimeInSeconds >= 0),
() => Assert.Equal(-1, catResponseData.ContentLength),
() => Assert.NotNull(catResponseData.TransactionGuid),
() => Assert.False(catResponseData.Unused),
// Trace attributes
() => Assertions.TransactionTraceHasAttributes(Expectations.ExpectedTransactionTraceIntrinsicAttributesCatEnabled, TransactionTraceAttributeType.Intrinsic, transactionSample),
() => Assertions.TransactionTraceDoesNotHaveAttributes(Expectations.UnexpectedTransactionTraceIntrinsicAttributesCatEnabled, TransactionTraceAttributeType.Intrinsic, transactionSample),
// Event attributes
() => Assertions.TransactionEventHasAttributes(Expectations.ExpectedTransactionEventIntrinsicAttributesCatEnabled, TransactionEventAttributeType.Intrinsic, transactionEvent),
() => Assertions.TransactionEventDoesNotHaveAttributes(Expectations.UnexpectedTransactionEventIntrinsicAttributesCatEnabled, TransactionEventAttributeType.Intrinsic, transactionEvent),
() => Assertions.MetricsExist(Expectations.ExpectedMetricsCatEnabled, metrics)
);
}
public void Test()
{
NrAssert.Multiple(
() => Assert.Contains("NREUM", _browserTimingHeader),
ShouldNotAutoInstrumentAfterCallToGetBrowserTimingHeader
);
var browserMonitoringConfig = JavaScriptAgent.GetJavaScriptAgentConfigFromSource(_browserTimingHeader);
NrAssert.Multiple(
() => Assert.Contains("beacon", browserMonitoringConfig.Keys),
() => Assert.Contains("errorBeacon", browserMonitoringConfig.Keys),
() => Assert.Contains("licenseKey", browserMonitoringConfig.Keys),
() => Assert.Contains("applicationID", browserMonitoringConfig.Keys),
() => Assert.Contains("transactionName", browserMonitoringConfig.Keys),
() => Assert.Contains("queueTime", browserMonitoringConfig.Keys),
() => Assert.Contains("applicationTime", browserMonitoringConfig.Keys),
() => Assert.Contains("agent", browserMonitoringConfig.Keys),
() => Assert.Contains("atts", browserMonitoringConfig.Keys)
);
var attrsDict = HeaderEncoder.DecodeAndDeserialize <Dictionary <string, IDictionary <string, object> > >(browserMonitoringConfig["atts"], _fixture.TestConfiguration.LicenseKey, 13);
Assert.Contains("a", attrsDict.Keys);
IDictionary <string, object> agentAttrsDict = attrsDict["a"];
Assert.Contains("nr.tripId", agentAttrsDict.Keys);
NrAssert.Multiple(
() => Assert.NotNull(browserMonitoringConfig["beacon"]),
() => Assert.NotNull(browserMonitoringConfig["errorBeacon"]),
() => Assert.NotNull(browserMonitoringConfig["licenseKey"]),
() => Assert.NotNull(browserMonitoringConfig["applicationID"]),
() => Assert.NotNull(browserMonitoringConfig["transactionName"]),
() => Assert.NotNull(browserMonitoringConfig["queueTime"]),
() => Assert.NotNull(browserMonitoringConfig["applicationTime"]),
() => Assert.NotNull(browserMonitoringConfig["agent"])
);
}
public void CAT()
{
var assertions = new List <Action>();
if (_tracingTestOption != TracingTestOption.CAT)
{
return;
}
//We do this assertion here so that we don't pass this test if transactions have not been generated
NrAssert.Multiple(
() => Assert.NotEmpty(LogHelpers.TrxEvents),
() => Assert.NotEmpty(LogHelpers.TrxEvents_Client),
() => Assert.NotEmpty(LogHelpers.TrxEvents_Service));
var catAttributes = new[]
{
"nr.guid",
"nr.tripId",
"nr.pathHash",
"nr.referringPathHash",
"nr.referringTransactionGuid"
};
foreach (var trx in LogHelpers.TrxEvents_Service)
{
var svcTrx = trx;
//Assert that the transaction has the DT attributes
assertions.Add(() => Assertions.TransactionEventHasAttributes(catAttributes, TransactionEventAttributeType.Intrinsic, svcTrx));
//Given the ParentID on the Svc Transcation, we should find the client transaction that matches.
var referringTrxId = svcTrx.IntrinsicAttributes["nr.referringTransactionGuid"].ToString();
assertions.Add(() => Assert.True(LogHelpers.TrxTripIDs_Client.Contains(referringTrxId), $"Service Transaction's referringTransactionGuid={referringTrxId}, could not find corresponding client transaction."));
}
NrAssert.Multiple(assertions.ToArray());
}
public void Transform_FiltersAttributesBeforeSendingThemToErrorTraceMaker()
{
// ARRANGE
var attribValues = new AttributeValueCollection(AttributeDestinations.TransactionEvent, AttributeDestinations.ErrorEvent, AttributeDestinations.ErrorTrace, AttributeDestinations.JavaScriptAgent);;
_attribDefs.GetCustomAttributeForCustomEvent("CustomEventAttrib").TrySetValue(attribValues, "CustomEventValue"); //CustomEvent
_attribDefs.GetCustomAttributeForError("ErrorEventAttrib").TrySetValue(attribValues, "ErrorEventValue"); //Error Event and Trace
_attribDefs.GetCustomAttributeForSpan("SpanEventAttrib").TrySetValue(attribValues, "SpanEventValue"); //Span only
_attribDefs.GetCustomAttributeForTransaction("TrxEventAttrib").TrySetValue(attribValues, "TrxEventValue"); //All Destiantions
var errorCustomParameters = new ReadOnlyDictionary <string, object>(new Dictionary <string, object>()
{
{ "ErrorCustomAttrib", "ErrorCustomValue" }
});
var errorNoticedAt = DateTime.Now;
var errorMsg = "ErrorMessage";
var errorType = "ErrorType";
var stackTrace = "StackTrace";
var errorData = new ErrorData(errorMsg, errorType, stackTrace, errorNoticedAt, errorCustomParameters, false);
// ACT
var errorTrace = _errorTraceMaker.GetErrorTrace(attribValues, errorData);
//CAPTURE
var userAttribs = errorTrace.Attributes.UserAttributes;
//ASSERT
NrAssert.Multiple
(
() => Assert.AreEqual(errorType, errorTrace.ExceptionClassName),
() => Assert.AreEqual(errorMsg, errorTrace.Message),
() => Assert.AreEqual(errorNoticedAt, errorTrace.TimeStamp),
() => Assert.AreEqual(2, userAttribs.Count),
() => Assert.AreEqual("TrxEventValue", userAttribs["TrxEventAttrib"]),
() => Assert.AreEqual("ErrorEventValue", userAttribs["ErrorEventAttrib"])
);
}
public void Test()
{
var expectedAttributes = new List <string>()
{
"type",
"traceId",
"guid",
"transactionId",
"sampled",
"priority",
"timestamp",
"duration",
"name",
"category"
};
var expectedAgentAttributes = new List <string>()
{
"error.class",
"error.message"
};
var unexpectedAttributes = new List <string>()
{
"parentId"
};
var spanEvents = _fixture.AgentLog.GetSpanEvents().ToList();
var rootSpanEvent = spanEvents.FirstOrDefault(se => se.IntrinsicAttributes.ContainsKey("nr.entryPoint"));
var nonRootSpanEvent = spanEvents.FirstOrDefault(se => se.IntrinsicAttributes.ContainsKey("parentId"));
NrAssert.Multiple(
() => Assertions.SpanEventHasAttributes(expectedAttributes, SpanEventAttributeType.Intrinsic, rootSpanEvent),
() => Assertions.SpanEventDoesNotHaveAttributes(unexpectedAttributes, SpanEventAttributeType.Intrinsic, rootSpanEvent),
() => Assert.Empty(rootSpanEvent.GetByType(SpanEventAttributeType.User)),
() => Assertions.SpanEventHasAttributes(expectedAgentAttributes, SpanEventAttributeType.Agent, rootSpanEvent),
() => Assert.Equal(rootSpanEvent.IntrinsicAttributes["guid"], nonRootSpanEvent.IntrinsicAttributes["parentId"])
);
}
public void QueueSize_PartitionedCorrectly(int configQueueSize, int configPartitionCount)
{
Mock.Arrange(() => _currentConfiguration.InfiniteTracingPartitionCountSpans).Returns(configPartitionCount);
Mock.Arrange(() => _currentConfiguration.InfiniteTracingQueueSizeSpans).Returns(configQueueSize);
var streamingSvc = GetMockStreamingService(true, true);
PartitionedBlockingCollection <Span> actualCollection = default;
Mock.Arrange(() => streamingSvc.StartConsumingCollection(Arg.IsAny <PartitionedBlockingCollection <Span> >()))
.DoInstead <PartitionedBlockingCollection <Span> >((c) => { actualCollection = c; });
var aggregator = CreateAggregator(streamingSvc);
FireAgentConnectedEvent();
NrAssert.Multiple
(
() => Assert.AreEqual(configQueueSize, aggregator.Capacity),
() => Assert.AreEqual(configQueueSize, actualCollection.Capacity)
);
}
public void AggregatorIsAvailableRespondsToStreamingService
(
[Values(true, false)] bool streamingSvcAvailable,
[Values(true, false)] bool streamingSvcEnabled,
[Values(true, false)] bool aggregatorHasValidConfig
)
{
Mock.Arrange(() => _currentConfiguration.InfiniteTracingTraceObserverHost).Returns(streamingSvcEnabled ? "infiniteTracing.net" : null as string);
Mock.Arrange(() => _currentConfiguration.InfiniteTracingQueueSizeSpans).Returns(aggregatorHasValidConfig ? 10 : -1);
var streamingSvc = GetMockStreamingService(streamingSvcEnabled, streamingSvcAvailable);
var aggregator = CreateAggregator(streamingSvc);
FireAgentConnectedEvent();
NrAssert.Multiple
(
() => Assert.AreEqual(aggregator.IsServiceAvailable, streamingSvcAvailable && streamingSvcEnabled && aggregatorHasValidConfig),
() => Assert.AreEqual(aggregator.IsServiceEnabled, streamingSvcEnabled)
);
}
public void Attributes_key_size()
{
var filter = new AttributeFilter(new AttributeFilter.Settings());
var attribVals = new AttributeValueCollection(AttributeValueCollection.AllTargetModelTypes);
var testKeys = new string[]
{
new string('x', 255),
new string('a', 256),
string.Empty,
" ",
null as string
};
var testResults = new bool[testKeys.Length];
for (var i = 0; i < testKeys.Length; i++)
{
var attribDef = AttributeDefinitionBuilder
.CreateCustomAttribute(testKeys[i], AttributeDestinations.All)
.Build(filter);
testResults[i] = attribDef.IsDefinitionValid;
attribDef.TrySetValue(attribVals, 9);
}
NrAssert.Multiple(
() => Assert.IsTrue(testResults[0]),
() => Assert.IsFalse(testResults[1]),
() => Assert.IsFalse(testResults[2]),
() => Assert.IsFalse(testResults[3]),
() => Assert.IsFalse(testResults[4]),
() => Assert.AreEqual(1, attribVals.GetAttributeValues(AttributeClassification.UserAttributes).Count())
);
}
public void slowest_traces_are_retained_if_too_many_traces()
{
// Arrange
var sqlTracesPerPeriod = 5;
var configuration = GetDefaultConfiguration(int.MaxValue, sqlTracesPerPeriod);
EventBus <ConfigurationUpdatedEvent> .Publish(new ConfigurationUpdatedEvent(configuration, ConfigurationUpdateSource.Local));
var sentSqlTraces = null as IEnumerable <SqlTraceWireModel>;
Mock.Arrange(() => _dataTransportService.Send(Arg.IsAny <IEnumerable <SqlTraceWireModel> >()))
.DoInstead <IEnumerable <SqlTraceWireModel> >(sqlTraces => sentSqlTraces = sqlTraces);
var sqlTracesToSend = new SqlTraceStatsCollection();
sqlTracesToSend.Insert(GetSqlTrace(1, maxCallTime: TimeSpan.FromSeconds(10)));
sqlTracesToSend.Insert(GetSqlTrace(2, maxCallTime: TimeSpan.FromSeconds(999)));
sqlTracesToSend.Insert(GetSqlTrace(3, maxCallTime: TimeSpan.FromSeconds(30)));
sqlTracesToSend.Insert(GetSqlTrace(4, maxCallTime: TimeSpan.FromSeconds(40)));
sqlTracesToSend.Insert(GetSqlTrace(5, maxCallTime: TimeSpan.FromSeconds(50)));
sqlTracesToSend.Insert(GetSqlTrace(6, maxCallTime: TimeSpan.FromSeconds(60)));
sqlTracesToSend.Insert(GetSqlTrace(7, maxCallTime: TimeSpan.FromSeconds(70)));
_sqlTraceAggregator.Collect(sqlTracesToSend);
// Act
_harvestAction();
// Assert
NrAssert.Multiple(
() => Assert.AreEqual(sqlTracesPerPeriod, sentSqlTraces.Count()),
() => Assert.IsTrue(sentSqlTraces.Any(trace => trace.SqlId == 2)),
() => Assert.IsTrue(sentSqlTraces.Any(trace => trace.SqlId == 4)),
() => Assert.IsTrue(sentSqlTraces.Any(trace => trace.SqlId == 5)),
() => Assert.IsTrue(sentSqlTraces.Any(trace => trace.SqlId == 6)),
() => Assert.IsTrue(sentSqlTraces.Any(trace => trace.SqlId == 7))
);
}
public void Test()
{
var expectedMetrics = new List <Assertions.ExpectedMetric>
{
new Assertions.ExpectedMetric {
metricName = @"WebTransaction", callCount = 2
},
new Assertions.ExpectedMetric {
metricName = @"WebTransactionTotalTime", callCount = 2
},
new Assertions.ExpectedMetric {
metricName = @"WebTransaction/MVC/Values/Get", callCount = 2
},
new Assertions.ExpectedMetric {
metricName = @"DotNet/Middleware Pipeline", callCount = 2
},
new Assertions.ExpectedMetric {
metricName = @"DotNet/Middleware Pipeline", metricScope = @"WebTransaction/MVC/Values/Get", callCount = 2
},
new Assertions.ExpectedMetric {
metricName = @"DotNet/ValuesController/Get", callCount = 2
},
new Assertions.ExpectedMetric {
metricName = @"DotNet/ValuesController/Get", metricScope = @"WebTransaction/MVC/Values/Get", callCount = 2
},
};
var metrics = _fixture.AgentLog.GetMetrics().ToList();
var exceptionHandlerFeatureErrorLogLines = _fixture.AgentLog.TryGetLogLines("Inspecting errors from the IExceptionHandlerFeature is disabled");
Assert.NotNull(metrics);
NrAssert.Multiple
(
() => Assertions.MetricsExist(expectedMetrics, metrics),
() => Assert.Single(exceptionHandlerFeatureErrorLogLines)
);
}
public void Test()
{
var expectedMetrics = new List <Assertions.ExpectedMetric>
{
new Assertions.ExpectedMetric {
metricName = @"DotNet/default.aspx", metricScope = "WebTransaction/ASP/default.aspx", callCount = 1
},
};
var expectedTransactionTraceSegments = new List <string>
{
@"AuthenticateRequest",
@"AuthorizeRequest",
@"ResolveRequestCache",
@"MapRequestHandler",
@"AcquireRequestState",
@"ExecuteRequestHandler",
@"default.aspx",
@"ReleaseRequestState",
@"UpdateRequestCache",
@"EndRequest",
};
var metrics = _fixture.AgentLog.GetMetrics().ToList();
var transactionSample = _fixture.AgentLog.GetTransactionSamples()
.Where(sample => sample.Path == @"WebTransaction/ASP/default.aspx")
.FirstOrDefault();
Assert.NotNull(transactionSample);
NrAssert.Multiple(
() => Assertions.MetricsExist(expectedMetrics, metrics),
() => Assertions.TransactionTraceSegmentsExist(expectedTransactionTraceSegments, transactionSample),
() => Assert.Empty(_fixture.AgentLog.GetErrorTraces()),
() => Assert.Empty(_fixture.AgentLog.GetErrorEvents())
);
}
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 ShouldResetThreadpoolThroughputStatsWhenSampled()
{
using (var eventSource = new TestEventSource())
using (var threadEventListener = CreateThreadEventsListener())
{
eventSource.EnqueueThread();
eventSource.EnqueueThread();
eventSource.EnqueueThread();
eventSource.DequeueThread();
eventSource.DequeueThread();
threadEventListener.Sample(); //This call should reset the accumulated stats
var sample = threadEventListener.Sample();
NrAssert.Multiple(
() => Assert.AreEqual(0, sample.CountThreadRequestsQueued),
() => Assert.AreEqual(0, sample.CountThreadRequestsDequeued),
() => Assert.AreEqual(1, sample.ThreadRequestQueueLength) //Queue length does not reset
);
}
}
public void all_attributes_included()
{
_attribDefs.TransactionName.TrySetValue(_attribValues, "name");
_attribDefs.HostDisplayName.TrySetValue(_attribValues, "host");
_attribDefs.GetCustomAttributeForTransaction("custom1Name").TrySetValue(_attribValues, "custom1Value");
var expectedIntrisicDictionary = new Dictionary <string, object> {
{ "name", "name" }
};
var expectedAgentDictionary = new Dictionary <string, object> {
{ "host.displayName", "host" }
};
var expectedUserDictionary = new Dictionary <string, object> {
{ "custom1Name", "custom1Value" }
};
NrAssert.Multiple
(
() => CollectionAssert.AreEquivalent(expectedIntrisicDictionary, _attribValues.ToDictionary(AttributeClassification.Intrinsics)),
() => CollectionAssert.AreEquivalent(expectedAgentDictionary, _attribValues.ToDictionary(AttributeClassification.AgentAttributes)),
() => CollectionAssert.AreEquivalent(expectedUserDictionary, _attribValues.ToDictionary(AttributeClassification.UserAttributes))
);
}
public void Test()
{
var transactionSample = _fixture.AgentLog.TryGetTransactionSample("WebTransaction/MVC/DefaultController/Index");
var transactionEvent = _fixture.AgentLog.TryGetTransactionEvent("WebTransaction/MVC/DefaultController/Index");
var metrics = _fixture.AgentLog.GetMetrics();
NrAssert.Multiple(
() => Assert.NotNull(transactionSample),
() => Assert.NotNull(transactionEvent)
);
NrAssert.Multiple(
() => Assert.False(_responseHeaders.Contains(@"X-NewRelic-App-Data")),
// Trace attributes
() => Assertions.TransactionTraceDoesNotHaveAttributes(Expectations.UnexpectedTransactionTraceIntrinsicAttributesCatDisabled, TransactionTraceAttributeType.Intrinsic, transactionSample),
// Event attributes
() => Assertions.TransactionEventDoesNotHaveAttributes(Expectations.UnexpectedTransactionEventIntrinsicAttributesCatDisabled, TransactionEventAttributeType.Intrinsic, transactionEvent),
() => Assertions.MetricsDoNotExist(Expectations.UnexpectedMetricsCatDisabled, metrics)
);
}
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)
);
}
public void SingleAddedSegment_IsNestedBelowRootSegment()
{
var tx = _agent.CreateTransaction(
isWeb: true,
category: EnumNameCache <WebTransactionType> .GetName(WebTransactionType.Action),
transactionDisplayName: "name",
doNotTrackAsUnitOfWork: true);
var segment = _agent.StartTransactionSegmentOrThrow("childSegment");
segment.End();
tx.End();
_compositeTestAgent.Harvest();
var rootSegment = GetFirstSegmentOrThrow();
NrAssert.Multiple(
() => Assert.AreEqual(1, rootSegment.Children.Count),
() => Assert.AreEqual("childSegment", rootSegment.Children[0].Name),
() => Assert.AreEqual(0, rootSegment.Children[0].Children.Count)
);
}
public void DuplicateAttibuteKeepsLastValue()
{
_attribDefs.OriginalUrl.TrySetValue(_attribValues, "banana1");
_attribDefs.OriginalUrl.TrySetValue(_attribValues, "banana2");
_attribDefs.GetCustomAttributeForTransaction("pie").TrySetValue(_attribValues, "cake1");
_attribDefs.GetCustomAttributeForTransaction("pie").TrySetValue(_attribValues, "cake2");
var agentAttribsDic = _attribValues.GetAttributeValuesDic(AttributeClassification.AgentAttributes);
var userAttribsDic = _attribValues.GetAttributeValuesDic(AttributeClassification.UserAttributes);
var allAttribs = _attribValues.GetAttributeValues(AttributeClassification.Intrinsics)
.Union(_attribValues.GetAttributeValues(AttributeClassification.AgentAttributes))
.Union(_attribValues.GetAttributeValues(AttributeClassification.UserAttributes))
.ToList();
NrAssert.Multiple
(
() => Assert.AreEqual(2, allAttribs.Count),
() => Assert.AreEqual(1, agentAttribsDic.Count()),
() => Assert.AreEqual("banana2", agentAttribsDic["original_url"]),
() => Assert.AreEqual(1, userAttribsDic.Count()),
() => Assert.AreEqual("cake2", userAttribsDic["pie"])
);
}
public void Merge_MergesThreeMetricsCorrectly_WhenMergedProgressively()
{
var metric1 = MetricWireModel.BuildMetric(_metricNameService, "DotNet/name", "scope",
MetricDataWireModel.BuildTimingData(TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(1)));
var metric2 = MetricWireModel.BuildMetric(_metricNameService, "DotNet/name", "scope",
MetricDataWireModel.BuildTimingData(TimeSpan.FromSeconds(7), TimeSpan.FromSeconds(5)));
var metric3 = MetricWireModel.BuildMetric(_metricNameService, "DotNet/name", "scope",
MetricDataWireModel.BuildTimingData(TimeSpan.FromSeconds(13), TimeSpan.FromSeconds(11)));
var mergedMetric = MetricWireModel.Merge(new[] { metric1, metric2 });
mergedMetric = MetricWireModel.Merge(new[] { mergedMetric, metric3 });
NrAssert.Multiple(
() => Assert.AreEqual("DotNet/name", mergedMetric.MetricName.Name),
() => Assert.AreEqual(3, mergedMetric.Data.Value0),
() => Assert.AreEqual(23, mergedMetric.Data.Value1),
() => Assert.AreEqual(17, mergedMetric.Data.Value2),
() => Assert.AreEqual(3, mergedMetric.Data.Value3),
() => Assert.AreEqual(13, mergedMetric.Data.Value4),
() => Assert.AreEqual(227, mergedMetric.Data.Value5)
);
}
public void only_agent_and_custom_attributes_should_be_filtered_when_all_attributes_excluded()
{
_compositeTestAgent.LocalConfiguration.attributes.exclude = new List <string> {
"*"
};
_compositeTestAgent.PushConfiguration();
_attribDefs.TransactionName.TrySetValue(_attribValues, "name");
_attribDefs.HostDisplayName.TrySetValue(_attribValues, "host");
_attribDefs.GetCustomAttributeForTransaction("custom1Name").TrySetValue(_attribValues, "custom1Value");
var expectedIntrisicDictionary = new Dictionary <string, object> {
{ "name", "name" }
};
NrAssert.Multiple
(
() => CollectionAssert.AreEquivalent(expectedIntrisicDictionary, _attribValues.ToDictionary(AttributeClassification.Intrinsics)),
() => CollectionAssert.IsEmpty(_attribValues.ToDictionary(AttributeClassification.AgentAttributes), "Agent attributes were not empty."),
() => CollectionAssert.IsEmpty(_attribValues.ToDictionary(AttributeClassification.UserAttributes), "Custom attributes were not empty.")
);
}
public void Test()
{
var expectedTransactionTraceAttributes = new Dictionary <string, string>
{
{ "foo", "bar" }
};
var unexpectedTransactionTraceAttributes = new List <string>
{
"key"
};
var transactionSample = _fixture.AgentLog.GetTransactionSamples().FirstOrDefault();
Assert.NotNull(transactionSample);
var maybeDeprecationMessage = _fixture.AgentLog.TryGetLogLine(AgentLogBase.WarnLogLinePrefixRegex + @"Deprecated configuration property 'parameterGroups.customParameters.ignore'. Use 'attributes.exclude'. See http://docs.newrelic.com for details.");
NrAssert.Multiple
(
() => Assertions.TransactionTraceHasAttributes(expectedTransactionTraceAttributes, TransactionTraceAttributeType.User, transactionSample),
() => Assertions.TransactionTraceDoesNotHaveAttributes(unexpectedTransactionTraceAttributes, TransactionTraceAttributeType.User, transactionSample),
() => Assert.NotNull(maybeDeprecationMessage)
);
}
public void RequestUriInTransactionTrace()
{
var tx = _agent.CreateTransaction(
isWeb: true,
category: EnumNameCache <WebTransactionType> .GetName(WebTransactionType.Action),
transactionDisplayName: "name",
doNotTrackAsUnitOfWork: true);
tx.SetUri("myuri");
var segment = _agent.StartTransactionSegmentOrThrow("segmentName");
segment.End();
tx.End();
_compositeTestAgent.Harvest();
var transactionTrace = _compositeTestAgent.TransactionTraces.First();
NrAssert.Multiple(
() => Assert.AreEqual("myuri", transactionTrace.GetAttributes(AttributeClassification.AgentAttributes)["request.uri"]),
() => Assert.AreEqual("myuri", transactionTrace.Uri)
);
}
