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