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