/// <summary>
/// Protected Constructor
/// </summary>
/// <param name="categoryName"></param>
/// <param name="instanceName"></param>
protected CounterHandlerBase(string categoryName, string instanceName)
{
CategoryName = categoryName;
InstanceName = instanceName;
Name = CounterType;
UniqueName = PerfItRuntime.GetUniqueName(instanceName, Name);
}
/// <summary>
///
/// </summary>
/// <param name="configuration">Hosting configuration</param>
/// <param name="applicationName">Name of the web application. It will be used as counetrs instance name</param>
public PerfItDelegatingHandler(HttpConfiguration configuration, string applicationName)
{
_applicationName = applicationName;
_configuration = configuration;
var filters = PerfItRuntime.FindAllFilters();
foreach (var filter in filters)
{
foreach (var counterType in filter.Counters)
{
if (!PerfItRuntime.HandlerFactories.ContainsKey(counterType))
{
throw new ArgumentException("Counter type not registered: " + counterType);
}
var counterHandler = PerfItRuntime.HandlerFactories[counterType](applicationName, filter);
if (!_counterContexts.Keys.Contains(counterHandler.Name))
{
_counterContexts.Add(counterHandler.Name, new PerfItCounterContext()
{
Handler = counterHandler,
Name = counterHandler.Name
});
}
}
}
}
public SimpleInstrumentor(IInstrumentationInfo info)
{
_info = info;
_info.CorrelationIdKey = _info.CorrelationIdKey ?? Correlation.CorrelationIdKey;
_tracers.Add("EventSourceTracer", new EventSourceTracer());
#if NET452
if (_info.PublishCounters)
{
_tracers.Add("PerformanceCounterTracer", new PerformanceCounterTracer(info));
}
#endif
PerfItRuntime.OnInstrumentorCreated(new InstrumentorCreatedArgs(this, info));
}
public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
{
base.OnActionExecuted(actionExecutedContext);
bool raiseErrors = true;
if (actionExecutedContext.Request.Properties.ContainsKey(Constants.PerfItPublishErrorsKey))
{
raiseErrors =
Convert.ToBoolean(actionExecutedContext.Request.Properties[Constants.PerfItPublishErrorsKey]);
}
try
{
var instanceName = InstanceName;
if (string.IsNullOrEmpty(instanceName))
{
HttpActionContext actionContext = actionExecutedContext.ActionContext;
HttpActionDescriptor actionDescriptor = actionContext.ActionDescriptor;
instanceName = PerfItRuntime.GetCounterInstanceName(actionDescriptor.ControllerDescriptor.ControllerType,
actionDescriptor.ActionName);
}
if (actionExecutedContext.Request.Properties.ContainsKey(Constants.PerfItKey))
{
var context = (PerfItContext)actionExecutedContext.Request.Properties[Constants.PerfItKey];
foreach (var counter in Counters)
{
context.CountersToRun.Add(PerfItRuntime.GetUniqueName(instanceName, counter));
}
context.Filter = this;
}
}
catch (Exception exception)
{
Trace.TraceError(exception.ToString());
if (raiseErrors)
{
throw exception;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="categoryName">Name of the grouping category of counters (e.g. Process, Processor, Network Interface are all categories)
/// if not provided, it will use name of the assembly.
/// </param>
public PerfItDelegatingHandler(string categoryName = null)
{
PublishCounters = true;
RaisePublishErrors = true;
SetPublish();
SetErrorPolicy();
var frames = new StackTrace().GetFrames();
var assembly = frames[1].GetMethod().ReflectedType.Assembly;
if (string.IsNullOrEmpty(categoryName))
{
categoryName = assembly.GetName().Name;
}
var filters = PerfItRuntime.FindAllFilters(assembly);
foreach (var filter in filters)
{
foreach (var counterType in filter.Counters)
{
if (!PerfItRuntime.HandlerFactories.ContainsKey(counterType))
{
throw new ArgumentException("Counter type not registered: " + counterType);
}
var counterHandler = PerfItRuntime.HandlerFactories[counterType](categoryName, filter.InstanceName);
if (!_counterContexts.Keys.Contains(counterHandler.UniqueName))
{
_counterContexts.Add(counterHandler.UniqueName, new PerfItCounterContext()
{
Handler = counterHandler,
Name = counterHandler.UniqueName
});
}
}
}
}
protected void SetSamplingRate()
{
SamplingRate = PerfItRuntime.GetSamplingRate(CategoryName, SamplingRate);
}
protected void SetEventPolicy()
{
PublishEvent = PerfItRuntime.IsPublishEventsEnabled(CategoryName, PublishEvent);
}
protected void SetErrorPolicy()
{
RaisePublishErrors = PerfItRuntime.IsPublishErrorsEnabled(CategoryName, RaisePublishErrors);
}
private void SetPublish()
{
PublishCounters = PerfItRuntime.IsPublishCounterEnabled(CategoryName, PublishCounters);
}
