/// <summary>
/// Creates the performance counters to instrument an <see cref="AuthorizationProvider"/>'s events.
/// </summary>
/// <param name="instanceNames">The instance names for the performance counters.</param>
protected override void CreatePerformanceCounters(string[] instanceNames)
{
authorizationCheckPerformedCounter
= factory.CreateCounter(PerformanceCountersCategoryName, AuthorizationCheckPerformedCounterName, instanceNames);
authorizationCheckFailedCounter
= factory.CreateCounter(PerformanceCountersCategoryName, AuthorizationCheckFailedCounterName, instanceNames);
}
public void CreatingTwoDifferentCountersWithSameInstanceNameResultsInTwoSeparateCountersBeingCreated()
{
EnterpriseLibraryPerformanceCounter first = factory.CreateCounter(categoryName, counterName, new string[] { "foo" });
EnterpriseLibraryPerformanceCounter second = factory.CreateCounter(categoryName, differentCounterName, new string[] { "foo" });
Assert.IsFalse(ReferenceEquals(first.Counters[0], second.Counters[0]));
}
/// <summary>
/// Creates the performance counters to instrument the caching events for the specified instance names.
/// </summary>
/// <param name="instanceNames">The instance names for the performance counters.</param>
protected override void CreatePerformanceCounters(string[] instanceNames)
{
connectionOpenedCounter = counterCache.CreateCounter(counterCategoryName, "Connections Opened/sec", instanceNames);
commandExecutedCounter = counterCache.CreateCounter(counterCategoryName, "Commands Executed/sec", instanceNames);
connectionFailedCounter = counterCache.CreateCounter(counterCategoryName, "Connections Failed/sec", instanceNames);
commandFailedCounter = counterCache.CreateCounter(counterCategoryName, "Commands Failed/sec", instanceNames);
}
public void IncrementsMultipleInstancesIndependently()
{
string firstInstanceName = "first";
string secondInstanceName = "second";
FixedPrefixNameFormatter formatter = new FixedPrefixNameFormatter("Baz - ");
var connectionOpenedCounter = new EnterpriseLibraryPerformanceCounter(
NewDataInstrumentationProvider.CounterCategoryName,
NewDataInstrumentationProvider.TotalConnectionOpenedCounter,
formatter.CreateName(firstInstanceName),
formatter.CreateName(secondInstanceName));
var firstProvider = new NewDataInstrumentationProvider(firstInstanceName, true, true, formatter);
var secondProvider = new NewDataInstrumentationProvider(secondInstanceName, true, true, formatter);
firstProvider.FireConnectionOpenedEvent();
Assert.AreEqual(1, connectionOpenedCounter.GetValueFor(formatter.CreateName(firstInstanceName)));
Assert.AreEqual(0, connectionOpenedCounter.GetValueFor(formatter.CreateName(secondInstanceName)));
secondProvider.FireConnectionOpenedEvent();
Assert.AreEqual(1, connectionOpenedCounter.GetValueFor(formatter.CreateName(firstInstanceName)));
Assert.AreEqual(1, connectionOpenedCounter.GetValueFor(formatter.CreateName(secondInstanceName)));
}
/// <summary>
/// Creates the performance counters to instrument the symmetric crypto events for the specified instance names.
/// </summary>
/// <param name="instanceNames">The instance names for the performance counters.</param>
protected override void CreatePerformanceCounters(string[] instanceNames)
{
symmetricEncryptionPerformedCounter
= factory.CreateCounter(counterCategoryName, "Symmetric Encryptions/sec", instanceNames);
symmetricDecryptionPerformedCounter
= factory.CreateCounter(counterCategoryName, "Symmetric Decryptions/sec", instanceNames);
}
public void SetUp()
{
nameFormatter = new FixedPrefixNameFormatter("Prefix - ");
formattedInstanceName = nameFormatter.CreateName(instanceName);
totalConnectionOpenedCounter = new EnterpriseLibraryPerformanceCounter(
NewDataInstrumentationProvider.CounterCategoryName,
NewDataInstrumentationProvider.TotalConnectionOpenedCounter,
formattedInstanceName);
totalConnectionFailedCounter = new EnterpriseLibraryPerformanceCounter(
NewDataInstrumentationProvider.CounterCategoryName,
NewDataInstrumentationProvider.TotalConnectionFailedCounter,
formattedInstanceName);
totalCommandsExecutedCounter = new EnterpriseLibraryPerformanceCounter(
NewDataInstrumentationProvider.CounterCategoryName,
NewDataInstrumentationProvider.TotalCommandsExecutedCounter,
formattedInstanceName);
totalCommandsFailedCounter = new EnterpriseLibraryPerformanceCounter(
NewDataInstrumentationProvider.CounterCategoryName,
NewDataInstrumentationProvider.TotalCommandsFailedCounter,
formattedInstanceName);
provider = new NewDataInstrumentationProvider(instanceName, true, true, nameFormatter);
ClearExistingCounts();
}
/// <summary>
/// Creates the performance counters to instrument the logging events to the instance names.
/// </summary>
/// <param name="instanceNames">The instance names for the performance counters.</param>
protected override void CreatePerformanceCounters(string[] instanceNames)
{
exceptionHandledCounter = factory.CreateCounter(counterCategoryName, "Exceptions Handled/sec", instanceNames);
exceptionHandlerExecutedCounter = factory.CreateCounter(counterCategoryName, "Exception Handlers Executed/sec", instanceNames);
totalExceptionsHandledCounter = factory.CreateCounter(counterCategoryName, TotalExceptionsHandled, instanceNames);
totalExceptionHandlersExecutedCounter = factory.CreateCounter(counterCategoryName, TotalExceptionHandlersExecuted, instanceNames);
}
public void WillEmbedSameNamedCounterInMultipleInstancesOfELCounter()
{
EnterpriseLibraryPerformanceCounter first = factory.CreateCounter(categoryName, counterName, new string[] { "foo" });
EnterpriseLibraryPerformanceCounter second = factory.CreateCounter(categoryName, counterName, new string[] { "foo" });
Assert.AreSame(first.Counters[0], second.Counters[0]);
}
protected override void CreatePerformanceCounters(string[] instanceNames)
{
logEventRaised = factory.CreateCounter(counterCategoryName, "Logging Events Raised/sec", instanceNames);
traceListenerEntryWritten = factory.CreateCounter(counterCategoryName, "Trace Listener Entries Written/sec", instanceNames);
totalLoggingEventsRaised = factory.CreateCounter(counterCategoryName, TotalLoggingEventsRaised, instanceNames);
totalTraceListenerEntriesWritten = factory.CreateCounter(counterCategoryName, TotalTraceListenerEntriesWritten, instanceNames);
}
public AverageTimeMeter(EnterpriseLibraryPerformanceCounter averageCounter, EnterpriseLibraryPerformanceCounter baseCounter, string instanceName = null)
{
this.stopWatch = new Stopwatch();
this.averageCounter = averageCounter;
this.baseCounter = baseCounter;
this.instanceName = instanceName;
this.stopWatch.Start();
}
/// <summary>
/// Creates the performance counters to instrument a <see cref="SecurityCacheProvider"/>'s events.
/// </summary>
/// <param name="instanceNames">The instance names for the performance counters.</param>
protected override void CreatePerformanceCounters(string[] instanceNames)
{
securityCacheReadPerformedCounter
= factory.CreateCounter(PerfomanceCountersCategoryName, SecurityCacheReadPerformedCounterName, instanceNames);
totalSecurityCacheReadPerformedCounter
= factory.CreateCounter(PerfomanceCountersCategoryName, TotalSecurityCacheReadPerformedCounterName, instanceNames);
}
public void CounterCreatedThroughFactoryCanBeIncremented()
{
EnterpriseLibraryPerformanceCounter counter = factory.CreateCounter(categoryName, counterName, new string[] { "foo", "bar" });
counter.Clear();
counter.Increment();
Assert.AreEqual(1L, counter.Counters[0].RawValue);
Assert.AreEqual(1L, counter.Counters[1].RawValue);
}
private void IncrementItemCounter(bool shouldIncrement, string counterName, string[] instances)
{
if (shouldIncrement)
{
EnterpriseLibraryPerformanceCounter counter = counterFactory.CreateCounter(
category, counterName, instances);
counter.Increment();
}
}
public void SetUp()
{
nameFormatter = new AppDomainNameFormatter(applicationInstanceName);
instrumentationProvider = new HashAlgorithmInstrumentationProvider(instanceName, true, true, nameFormatter);
formattedInstanceName = nameFormatter.CreateName(instanceName);
totalHashComparisonPerformedPerformanceCounter = new EnterpriseLibraryPerformanceCounter(HashAlgorithmInstrumentationProvider.counterCategoryName, HashAlgorithmInstrumentationProvider.TotalHashComparisonPerformedPerformanceCounterName, formattedInstanceName);
totalHashMismatchesPerformedPerformanceCounter = new EnterpriseLibraryPerformanceCounter(HashAlgorithmInstrumentationProvider.counterCategoryName, HashAlgorithmInstrumentationProvider.TotalHashMismatchesPerformedPerformanceCounterName, formattedInstanceName);
totalHashOperationPerformedPerformanceCounter = new EnterpriseLibraryPerformanceCounter(HashAlgorithmInstrumentationProvider.counterCategoryName, HashAlgorithmInstrumentationProvider.TotalHashOperationPerformedPerformanceCounterName, formattedInstanceName);
}
public void CreateAndClearCounter()
{
EnterpriseLibraryPerformanceCounter counter = counterFactory.CreateCounter(counterCategoryName, counterName, new string[] { "Total" });
counter.Clear();
long expected = 0;
Assert.AreEqual(expected, counter.Value);
}
public void WillCreateEnterpriseLibraryCounterWithSingleEmbeddedCounterWhenGivenSingleInstanceName()
{
EnterpriseLibraryPerformanceCounter counter = factory.CreateCounter(categoryName, counterName, new string[] { "foo" });
PerformanceCounter[] counters = counter.Counters;
Assert.AreEqual(1, counters.Length);
Assert.AreEqual("foo", counters[0].InstanceName);
Assert.AreEqual(counterName, counters[0].CounterName);
}
/// <summary>
/// Creates the performance counters to instrument the hash provider events for the specified instance names.
/// </summary>
/// <param name="instanceNames">The instance names for the performance counters.</param>
protected override void CreatePerformanceCounters(string[] instanceNames)
{
hashOperationPerformedCounter
= factory.CreateCounter(counterCategoryName, "Hash Operations/sec", instanceNames);
hashComparisonPerformedCounter
= factory.CreateCounter(counterCategoryName, "Hash Comparisons/sec", instanceNames);
hashMismatchDetectedCounter
= factory.CreateCounter(counterCategoryName, "Hash Mismatches/sec", instanceNames);
}
public void SetUp()
{
nameFormatter = new FixedPrefixNameFormatter("Prefix - ");
listener = new DataInstrumentationListener(instanceName, true, true, true, nameFormatter);
formattedInstanceName = nameFormatter.CreateName(instanceName);
totalConnectionOpenedCounter = new EnterpriseLibraryPerformanceCounter(counterCategoryName, TotalConnectionOpenedCounter, formattedInstanceName);
totalConnectionFailedCounter = new EnterpriseLibraryPerformanceCounter(counterCategoryName, TotalConnectionFailedCounter, formattedInstanceName);
totalCommandsExecutedCounter = new EnterpriseLibraryPerformanceCounter(counterCategoryName, TotalCommandsExecutedCounter, formattedInstanceName);
totalCommandsFailedCounter = new EnterpriseLibraryPerformanceCounter(counterCategoryName, TotalCommandsFailedCounter, formattedInstanceName);
}
public void CounterValueCanBeSet()
{
EnterpriseLibraryPerformanceCounter counter = counterFactory.CreateCounter(counterCategoryName, counterName, new string[] { "Total" });
counter.Clear();
long expected = 10;
counter.SetValueFor("Total", expected);
Assert.AreEqual(expected, counter.GetValueFor("Total"));
}
public void CounterValueSetForWrongNameHasNoEffect()
{
EnterpriseLibraryPerformanceCounter counter = counterFactory.CreateCounter(counterCategoryName, counterName, new string[] { "Total" });
counter.Clear();
long expected = 0;
counter.SetValueFor("wrong name", 1000);
Assert.AreEqual(expected, counter.GetValueFor("Total"));
}
public void WillCreateELCounterWithTwoEmbeddedCountersWhenGivenTwoInstanceNames()
{
EnterpriseLibraryPerformanceCounter counter = factory.CreateCounter(categoryName, counterName, new string[] { "foo", "bar" });
PerformanceCounter[] counters = counter.Counters;
Assert.AreEqual(2, counters.Length);
Assert.AreEqual(counterName, counters[0].CounterName);
Assert.AreEqual("foo", counters[0].InstanceName);
Assert.AreEqual("bar", counters[1].InstanceName);
}
public void CounterCanBeIncrementedByAnArbitraryQuantity()
{
EnterpriseLibraryPerformanceCounter counter = counterFactory.CreateCounter(counterCategoryName, counterName, new string[] { "Total" });
counter.Clear();
counter.IncrementBy(10);
long expected = 10;
Assert.AreEqual(expected, counter.Value);
}
protected override void CreatePerformanceCounters(string[] instanceNames)
{
this.connectionOpenedCounter = NewDataInstrumentationProvider.counterCache.CreateCounter("Enterprise Library Data Counters", "Connections Opened/sec", instanceNames);
this.commandExecutedCounter = NewDataInstrumentationProvider.counterCache.CreateCounter("Enterprise Library Data Counters", "Commands Executed/sec", instanceNames);
this.connectionFailedCounter = NewDataInstrumentationProvider.counterCache.CreateCounter("Enterprise Library Data Counters", "Connections Failed/sec", instanceNames);
this.commandFailedCounter = NewDataInstrumentationProvider.counterCache.CreateCounter("Enterprise Library Data Counters", "Commands Failed/sec", instanceNames);
this.totalConnectionOpenedCounter = NewDataInstrumentationProvider.counterCache.CreateCounter("Enterprise Library Data Counters", "Total Connections Opened", instanceNames);
this.totalConnectionFailedCounter = NewDataInstrumentationProvider.counterCache.CreateCounter("Enterprise Library Data Counters", "Total Connections Failed", instanceNames);
this.totalCommandsExecutedCounter = NewDataInstrumentationProvider.counterCache.CreateCounter("Enterprise Library Data Counters", "Total Commands Executed", instanceNames);
this.totalCommandsFailedCounter = NewDataInstrumentationProvider.counterCache.CreateCounter("Enterprise Library Data Counters", "Total Commands Failed", instanceNames);
}
public void SetUp()
{
formatter = new AppDomainNameFormatter();
formattedInstanceName = formatter.CreateName(instanceName);
enabledInstrumentationProvider = new SecurityCacheProviderInstrumentationProvider(instanceName, true, true, formatter);
disabledInstrumentationProvider = new SecurityCacheProviderInstrumentationProvider(instanceName, false, false, formatter);
totalSecurityCacheReadPerformedCounter = new EnterpriseLibraryPerformanceCounter(SecurityCacheProviderInstrumentationProvider.PerfomanceCountersCategoryName, SecurityCacheProviderInstrumentationProvider.TotalSecurityCacheReadPerformedCounterName, formattedInstanceName);
ClearCounters();
}
/// <summary>
/// Creates the performance counters to instrument the validation events to the instance names.
/// </summary>
/// <param name="instanceNames">The instance names for the performance counters.</param>
protected override void CreatePerformanceCounters(string[] instanceNames)
{
validationCall = new EnterpriseLibraryPerformanceCounter(counterCategoryName, "Number of Validation Calls");
validationSucceeded = new EnterpriseLibraryPerformanceCounter(counterCategoryName, "Number of Validation Successes");
validationFailures = new EnterpriseLibraryPerformanceCounter(counterCategoryName, "Number of Validation Failures");
validationCallPerSecond = new EnterpriseLibraryPerformanceCounter(counterCategoryName, "Validation Calls/sec");
validationSucceededPerSecond = new EnterpriseLibraryPerformanceCounter(counterCategoryName, "Validation Successes/sec");
validationFailuresPerSecond = new EnterpriseLibraryPerformanceCounter(counterCategoryName, "Validation Failures/sec");
percentageValidationSuccesses = new EnterpriseLibraryPerformanceCounter(counterCategoryName, "% Validation Successes");
percentageValidationSuccessesBase = new EnterpriseLibraryPerformanceCounter(counterCategoryName, "% Validation Successes Base");
}
public void SetUp()
{
formatter = new AppDomainNameFormatter();
formattedInstanceName = formatter.CreateName(instanceName);
enabledInstrumentationProvider = new AuthorizationProviderInstrumentationProvider(instanceName, true, true, formatter);
disabledInstrumentationProvider = new AuthorizationProviderInstrumentationProvider(instanceName, false, false, formatter);
totalAuthorizationCheckFailedCounter = new EnterpriseLibraryPerformanceCounter(AuthorizationProviderInstrumentationProvider.PerformanceCountersCategoryName, AuthorizationProviderInstrumentationProvider.TotalAuthorizationCheckFailedCounterName, formattedInstanceName);
totalAuthorizationCheckPerformedCounter = new EnterpriseLibraryPerformanceCounter(AuthorizationProviderInstrumentationProvider.PerformanceCountersCategoryName, AuthorizationProviderInstrumentationProvider.TotalAuthorizationCheckPerformedCounterName, formattedInstanceName);
ClearCounters();
}
public void CanIncrementByAnArbitraryQuantityDifferentInstancesOfSameCounter()
{
EnterpriseLibraryPerformanceCounter counter = counterFactory.CreateCounter(counterCategoryName, counterName, new string[] { "ctr1", "ctr2" });
counter.Clear();
counter.IncrementBy(10);
long expected = 10;
Assert.AreEqual(expected, counter.GetValueFor("ctr1"));
Assert.AreEqual(expected, counter.GetValueFor("ctr2"));
}
public void CounterValueSetForInstanceNameDoesNotUpdateOtherInstances()
{
EnterpriseLibraryPerformanceCounter counter = counterFactory.CreateCounter(counterCategoryName, counterName, new string[] { "Total", "A" });
counter.Clear();
long expected = 10;
counter.SetValueFor("Total", expected);
Assert.AreEqual(expected, counter.GetValueFor("Total"));
Assert.AreEqual(0L, counter.GetValueFor("A"));
}
public void AuthorizationFailureDoesUpdatePerformanceCountersIfEnabled()
{
EnterpriseLibraryPerformanceCounter performanceCounter
= CreatePerformanceCounter(AuthorizationProviderInstrumentationProvider.AuthorizationCheckFailedCounterName);
performanceCounter.Clear();
Assert.AreEqual(0L, performanceCounter.GetValueFor(formattedInstanceName));
FireAuthorizationCheckFailed(enabledInstrumentationProvider);
// Timing dependant
Assert.AreEqual(50L, performanceCounter.GetValueFor(formattedInstanceName));
}
public void SecurityCacheCheckDoesNotUpdatePerformanceCountersIfDisabled()
{
EnterpriseLibraryPerformanceCounter performanceCounter
= CreatePerformanceCounter(SecurityCacheProviderInstrumentationProvider.SecurityCacheReadPerformedCounterName);
performanceCounter.Clear();
Assert.IsTrue(performanceCounter.GetValueFor(formattedInstanceName) == 0);
FireSecurityCacheReadPerformed(disabledInstrumentationProvider);
// Timing dependant
Assert.IsTrue(performanceCounter.GetValueFor(formattedInstanceName) == 0);
}
