public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
ErrorTriggerAttribute attribute = parameter.GetCustomAttribute <ErrorTriggerAttribute>(inherit: false);
if (attribute == null)
{
return(Task.FromResult <ITriggerBinding>(null));
}
if (parameter.ParameterType != typeof(TraceFilter) &&
parameter.ParameterType != typeof(TraceEvent) &&
parameter.ParameterType != typeof(IEnumerable <TraceEvent>))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind ErrorTriggerAttribute to type '{0}'.", parameter.ParameterType));
}
return(Task.FromResult <ITriggerBinding>(new ErrorTriggerBinding(_config, context.Parameter)));
}
public void Throttle_Setter_ValidatesTimeSpan(string throttle)
{
ErrorTriggerAttribute attribute = new ErrorTriggerAttribute();
var exception = Assert.Throws<ArgumentException>(() =>
{
attribute.Throttle = throttle;
});
Assert.Equal("Invalid TimeSpan value specified.\r\nParameter name: value", exception.Message);
Assert.Equal("value", exception.ParamName);
}
public void Throttle_Setter_ValidatesTimeSpan(string throttle)
{
ErrorTriggerAttribute attribute = new ErrorTriggerAttribute();
var exception = Assert.Throws <ArgumentException>(() =>
{
attribute.Throttle = throttle;
});
Assert.Equal("Invalid TimeSpan value specified.\r\nParameter name: value", exception.Message);
Assert.Equal("value", exception.ParamName);
}
internal static TraceMonitor CreateTraceMonitor(ParameterInfo parameter, ITriggeredFunctionExecutor executor)
{
ErrorTriggerAttribute attribute = parameter.GetCustomAttribute <ErrorTriggerAttribute>(inherit: false);
// Determine whether this is a method level filter, and if so, create the filter
Func <TraceEvent, bool> methodFilter = null;
MethodInfo method = (MethodInfo)parameter.Member;
string functionLevelMessage = null;
if (method.Name.EndsWith(ErrorHandlerSuffix, StringComparison.OrdinalIgnoreCase))
{
string sourceMethodName = method.Name.Substring(0, method.Name.Length - ErrorHandlerSuffix.Length);
MethodInfo sourceMethod = method.DeclaringType.GetMethod(sourceMethodName);
if (sourceMethod != null)
{
string sourceMethodFullName = string.Format("{0}.{1}", method.DeclaringType.FullName, sourceMethod.Name);
methodFilter = p =>
{
FunctionInvocationException functionException = p.Exception as FunctionInvocationException;
return(p.Level == System.Diagnostics.TraceLevel.Error && functionException != null &&
string.Compare(functionException.MethodName, sourceMethodFullName, StringComparison.OrdinalIgnoreCase) == 0);
};
string sourceMethodShortName = string.Format("{0}.{1}", method.DeclaringType.Name, sourceMethod.Name);
functionLevelMessage = string.Format("Function '{0}' failed.", sourceMethodShortName);
}
}
string errorHandlerFullName = string.Format("{0}.{1}", method.DeclaringType.FullName, method.Name);
ErrorHandlers.Add(errorHandlerFullName);
// Create the TraceFilter instance
TraceFilter traceFilter = null;
if (attribute.FilterType != null)
{
if (methodFilter != null)
{
TraceFilter innerTraceFilter = (TraceFilter)Activator.CreateInstance(attribute.FilterType);
traceFilter = new CompositeTraceFilter(innerTraceFilter, methodFilter, attribute.Message ?? functionLevelMessage);
}
else
{
traceFilter = (TraceFilter)Activator.CreateInstance(attribute.FilterType);
}
}
else if (!string.IsNullOrEmpty(attribute.Window))
{
TimeSpan window = TimeSpan.Parse(attribute.Window);
traceFilter = new SlidingWindowTraceFilter(window, attribute.Threshold, methodFilter, attribute.Message);
}
else
{
traceFilter = TraceFilter.Create(methodFilter, attribute.Message ?? functionLevelMessage);
}
TraceMonitor traceMonitor = new TraceMonitor().Filter(traceFilter);
// Apply any additional monitor options
if (!string.IsNullOrEmpty(attribute.Throttle))
{
TimeSpan throttle = TimeSpan.Parse(attribute.Throttle);
traceMonitor.Throttle(throttle);
}
// Subscribe the error handler function to the error stream
traceMonitor.Subscribe(p =>
{
TriggeredFunctionData triggerData = new TriggeredFunctionData
{
TriggerValue = p
};
Task <FunctionResult> task = executor.TryExecuteAsync(triggerData, CancellationToken.None);
task.Wait();
});
return(traceMonitor);
}
