public void ScanAssembly(Assembly scanAssembly)
{
// go through the types...
foreach (Type scanType in scanAssembly.GetTypes())
{
// get the attributes...
foreach (Type counterInterface in scanType.GetInterfaces())
{
// do we have one?
if (counterInterface == typeof(ICounterProvider))
{
// create it...
try
{
// call it and add it to the list...
ICounterProvider targetObject = (ICounterProvider)Activator.CreateInstance(scanType);
targetObject.CreateCounters(this);
_counterCapableObjects.Add(targetObject);
}
catch
{
}
}
}
}
}
public DatabaseCommandFactory(
IOptions <DatabaseSettings> databaseSettingsOptions,
ICounterProvider counterProvider)
{
this.databaseSettings = databaseSettingsOptions.Value;
this.counterProvider = counterProvider;
}
//
// Process counters instance names are not equivalent to their process IDs therefore a map must be generated to distinguish them
// key: process id
// value: process counter instance name
public static async Task <Dictionary <int, string> > GetProcessCounterMap(ICounterProvider provider, string processName)
{
var map = new Dictionary <int, string>();
var instances = (await provider.GetInstances(ProcessCounterNames.Category)).Where(instance => instance.StartsWith(processName, StringComparison.OrdinalIgnoreCase));
List <IPerfCounter> counters = new List <IPerfCounter>();
try {
foreach (string instance in instances)
{
counters.AddRange(await provider.GetCounters(ProcessCounterNames.Category, instance, ProcessCounterNames.CounterNames));
}
}
catch (MissingCountersException) {
//
// map will remain empty
}
foreach (IPerfCounter counter in counters)
{
if (counter.Name.Equals(ProcessCounterNames.ProcessId))
{
//
// process id fits in int
map[(int)counter.Value] = counter.InstanceName;
}
}
return(map);
}
public static ICounter GetLocalCounter(this ICounterProvider provider, string name)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
return(provider.GetCounter(name, distributed: false));
}
public static ICounter GetDistributedCounter <T>(this ICounterProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
return(provider.GetCounter <T>(distributed: true));
}
private static ICounter GetCounter <T>(this ICounterProvider provider, bool distributed)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
return(provider.GetCounter(TypeNameHelper.GetTypeDisplayName(typeof(T)), distributed));
}
/// <summary>
/// Initializes a new instance of the <see cref="AzureStorageUploadScheduler"/> class.
/// </summary>
public AzureStorageUploadScheduler(
ICounterProvider counterProvider,
CloudQueueClient queueClient)
{
this.counterProvider = counterProvider;
this.clients = new Dictionary <UploadProcessingMessagePriority, CloudQueue>
{
{ UploadProcessingMessagePriority.Low, GetQueue(queueClient, UploadProcessingMessagePriority.Low) },
{ UploadProcessingMessagePriority.High, GetQueue(queueClient, UploadProcessingMessagePriority.High) },
};
}
public UploadsController(
IDatabaseCommandFactory databaseCommandFactory,
GameData gameData,
IUserSettingsProvider userSettingsProvider,
TelemetryClient telemetryClient,
ICounterProvider counterProvider,
UserManager <ApplicationUser> userManager)
{
this.databaseCommandFactory = databaseCommandFactory;
this.gameData = gameData;
this.userSettingsProvider = userSettingsProvider;
this.telemetryClient = telemetryClient;
this.counterProvider = counterProvider;
this.userManager = userManager;
}
public DatabaseCommand(
DbConnection connection,
ICounterProvider counterProvider)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
if (counterProvider == null)
{
throw new ArgumentNullException("counterProvider");
}
this.command = connection.CreateCommand();
this.counterProvider = counterProvider;
}
public WebSiteMonitor(ICounterProvider counterProvider)
{
_counterProvider = counterProvider;
}
public WebServerMonitor(ICounterProvider provider)
{
_provider = provider;
}
/// <summary>
/// Initializes a new instance of the <see cref="MeasureLatencyFilter"/> class.
/// </summary>
public MeasureLatencyFilter(ICounterProvider counterProvider)
{
this.counterProvider = counterProvider;
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, ICounterProvider counterFactory)
{
loggerFactory.AddConsole();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
var counter = counterFactory.GetLocalCounter("counter");
app.Run(async(context) =>
{
await context.Response.WriteAsync("Hello World! " + counter.Value);
counter.Increment();
});
}
public CounterSpecialController(ICounterProvider counterProvider)
{
_counterProvider = counterProvider;
}
public CounterCheck(ICounterProvider counterProvider)
{
_counterProvider = counterProvider;
}
public AppPoolMonitor(ICounterProvider provider)
{
_counterProvider = provider;
}
public GetModel(ICounterProvider counterProvider)
{
_counterProvider = counterProvider;
}
public InsertModel(ICounterProvider counterProvider)
{
_counterProvider = counterProvider;
}
public CounterMiddleware(RequestDelegate next, ICounterProvider counterFactory)
{
_next = next;
_counter = counterFactory.GetLocalCounter("CounterMiddleware");
}
