public void DataClassHasCorrectDefaults()
{
PerformanceCounterCallHandlerData data =
new PerformanceCounterCallHandlerData("Counter data");
Assert.AreEqual(
PerformanceCounterCallHandlerDefaults.UseTotalCounter,
data.UseTotalCounter);
Assert.AreEqual(
PerformanceCounterCallHandlerDefaults.IncrementAverageCallDuration,
data.IncrementAverageCallDuration);
Assert.AreEqual(
PerformanceCounterCallHandlerDefaults.IncrementCallsPerSecond,
data.IncrementCallsPerSecond);
Assert.AreEqual(
PerformanceCounterCallHandlerDefaults.IncrementExceptionsPerSecond,
data.IncrementExceptionsPerSecond);
Assert.AreEqual(
PerformanceCounterCallHandlerDefaults.IncrementNumberOfCalls,
data.IncrementNumberOfCalls);
Assert.AreEqual(
PerformanceCounterCallHandlerDefaults.IncrementTotalExceptions,
data.IncrementTotalExceptions);
Assert.AreEqual(0, data.Order);
}
public void AssembledProperlyPerfCounterHandler()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policyData = new PolicyData("policy");
PerformanceCounterCallHandlerData data = new PerformanceCounterCallHandlerData("FooCallHandler", 2);
policyData.MatchingRules.Add(new CustomMatchingRuleData("match everything", typeof(AlwaysMatchingRule)));
policyData.Handlers.Add(data);
settings.Policies.Add(policyData);
DictionaryConfigurationSource dictConfigurationSource = new DictionaryConfigurationSource();
dictConfigurationSource.Add(PolicyInjectionSettings.SectionName, settings);
IUnityContainer container = new UnityContainer().AddNewExtension <Interception>();
settings.ConfigureContainer(container);
RuleDrivenPolicy policy = container.Resolve <RuleDrivenPolicy>("policy");
ICallHandler handler
= (policy.GetHandlersFor(GetMethodImpl(MethodBase.GetCurrentMethod()), container)).ElementAt(0);
Assert.IsNotNull(handler);
Assert.AreEqual(handler.Order, data.Order);
}
public void CanCreateRuleDataFromCustomAttributeMatchingRuleNode()
{
PerformanceCounterCallHandlerNode handlerNode = new PerformanceCounterCallHandlerNode();
handlerNode.Name = "perfCounterHandler";
handlerNode.CategoryName = "categoryName";
handlerNode.InstanceName = "instanceName";
handlerNode.IncrementAverageCallDuration = true;
handlerNode.IncrementCallsPerSecond = true;
handlerNode.IncrementExceptionsPerSecond = true;
handlerNode.IncrementNumberOfCalls = true;
handlerNode.IncrementTotalExceptions = true;
handlerNode.UseTotalCounter = true;
PerformanceCounterCallHandlerData handlerData = handlerNode.CreateCallHandlerData() as PerformanceCounterCallHandlerData;
Assert.IsNotNull(handlerData);
Assert.AreEqual(handlerNode.Name, handlerData.Name);
Assert.AreEqual(handlerNode.CategoryName, handlerData.CategoryName);
Assert.AreEqual(handlerNode.InstanceName, handlerData.InstanceName);
Assert.AreEqual(handlerNode.IncrementAverageCallDuration, handlerData.IncrementAverageCallDuration);
Assert.AreEqual(handlerNode.IncrementCallsPerSecond, handlerData.IncrementCallsPerSecond);
Assert.AreEqual(handlerNode.IncrementExceptionsPerSecond, handlerData.IncrementExceptionsPerSecond);
Assert.AreEqual(handlerNode.IncrementNumberOfCalls, handlerData.IncrementNumberOfCalls);
Assert.AreEqual(handlerNode.IncrementTotalExceptions, handlerData.IncrementTotalExceptions);
Assert.AreEqual(handlerNode.UseTotalCounter, handlerData.UseTotalCounter);
}
/// <summary>
/// Create a new <see cref="PerformanceCounterCallHandlerNode"/>
/// initialized from the configuration data given in <paramref name="callHandlerData"/>.
/// </summary>
/// <param name="callHandlerData">Source of configuration information.</param>
public PerformanceCounterCallHandlerNode(PerformanceCounterCallHandlerData callHandlerData)
: base(callHandlerData)
{
this.categoryName = callHandlerData.CategoryName;
this.instanceName = callHandlerData.InstanceName;
this.useTotalCounter = callHandlerData.UseTotalCounter;
this.incrementNumberOfCalls = callHandlerData.IncrementNumberOfCalls;
this.incrementAverageCallDuration = callHandlerData.IncrementAverageCallDuration;
this.incrementTotalExceptions = callHandlerData.IncrementTotalExceptions;
this.incrementExceptionsPerSecond = callHandlerData.IncrementExceptionsPerSecond;
this.incrementCallsPerSecond = callHandlerData.IncrementCallsPerSecond;
this.useTotalCounter = callHandlerData.UseTotalCounter;
}
public void CanDeserializeCallHandlerData()
{
PerformanceCounterCallHandlerData data = new PerformanceCounterCallHandlerData("counter data");
data.CategoryName = "My Category";
data.InstanceName = "Method - {namespace}.{type}.{method}";
data.UseTotalCounter = false;
PerformanceCounterCallHandlerData deserialized =
(PerformanceCounterCallHandlerData)SerializeAndDeserializeHandler(data);
Assert.AreEqual(data.Name, deserialized.Name);
Assert.AreEqual(data.CategoryName, deserialized.CategoryName);
Assert.AreEqual(data.InstanceName, deserialized.InstanceName);
}
/// <summary>
/// Convert the data stored into this node into the corresponding
/// configuration class (<see cref="PerformanceCounterCallHandlerData"/>).
/// </summary>
/// <returns>A configuration element to be stores into a configuration source.</returns>
public override CallHandlerData CreateCallHandlerData()
{
PerformanceCounterCallHandlerData callHandlerData = new PerformanceCounterCallHandlerData(Name);
callHandlerData.CategoryName = categoryName;
callHandlerData.InstanceName = instanceName;
callHandlerData.UseTotalCounter = useTotalCounter;
callHandlerData.IncrementAverageCallDuration = incrementAverageCallDuration;
callHandlerData.IncrementCallsPerSecond = incrementCallsPerSecond;
callHandlerData.IncrementExceptionsPerSecond = incrementExceptionsPerSecond;
callHandlerData.IncrementTotalExceptions = incrementTotalExceptions;
callHandlerData.IncrementNumberOfCalls = incrementNumberOfCalls;
return(callHandlerData);
}
static PolicyInjectionSettings GetInjectionSettings()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policy = new PolicyData("Intercept DoSomething");
policy.MatchingRules.Add(new MemberNameMatchingRuleData("Match DoSomething", "DoSomething"));
PerformanceCounterCallHandlerData handlerData =
new PerformanceCounterCallHandlerData("Perfcounters");
handlerData.CategoryName = "Category";
handlerData.InstanceName = "Instance";
policy.Handlers.Add(handlerData);
settings.Policies.Add(policy);
return(settings);
}
public void CanCreateCategoriesFromConfiguration()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policyData = new PolicyData("Perfmon policy");
//policyData.MatchingRules.Add(new TagAttributeMatchingRuleData("Match By Tag", "Perfmon"));
PerformanceCounterCallHandlerData counterData = new PerformanceCounterCallHandlerData("{type}.{method}");
counterData.CategoryName = firstCategory;
policyData.Handlers.Add(counterData);
settings.Policies.Add(policyData);
DictionaryConfigurationSource configSource = new DictionaryConfigurationSource();
configSource.Add(PolicyInjectionSettings.SectionName, settings);
PerformanceCountersInstaller installer = new PerformanceCountersInstaller(configSource);
CommitInstall(installer);
Assert.IsTrue(PerformanceCounterCategory.Exists(firstCategory));
Assert.IsFalse(PerformanceCounterCategory.Exists(secondCategory));
}
/// <summary>
/// Create the installer class, reading the categories from a policy set
/// configured in the given <paramref name="configurationSource"/>.
/// </summary>
/// <param name="configurationSource">Configuration source containing the policy set.</param>
public PerformanceCountersInstaller(IConfigurationSource configurationSource)
{
categoryNames = new List <string>();
PolicyInjectionSettings settings =
configurationSource.GetSection(PolicyInjectionSettings.SectionName) as PolicyInjectionSettings;
if (settings != null)
{
foreach (PolicyData policyData in settings.Policies)
{
foreach (CallHandlerData handlerData in policyData.Handlers)
{
PerformanceCounterCallHandlerData perfHandlerData =
handlerData as PerformanceCounterCallHandlerData;
if (perfHandlerData != null)
{
categoryNames.Add(perfHandlerData.CategoryName);
}
}
}
}
}
