public DefaultMetricValuesProviderTests(MetricCoreTestFixture fixture)
{
_provider = fixture.Snapshot;
_measure = fixture.Managers;
_clock = fixture.Clock;
_tags = fixture.Tags;
}
public static TweekManagementRulesDriver StartNew(HttpGet getter, TweekManagementRulesDriverSettings settings, ILogger logger = null,
IMeasureMetrics metrics = null, IScheduler scheduler = null)
{
var driver = new TweekManagementRulesDriver(getter, settings, logger,
metrics, scheduler);
driver.Start();
return(driver);
}
private static Func <T, Task <U> > MeasureAsync <T, U>(IMeasureMetrics metrics, string name, Func <T, Task <U> > mapFunc)
{
return(Optional(metrics)
.Match(someMetrics =>
async(T t) =>
{
using (someMetrics.Timer.Time(GetTimerOptions(name)))
{
return await mapFunc(t);
}
}, () => mapFunc));
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultMetrics" /> class.
/// </summary>
/// <param name="clock">The clock.</param>
/// <param name="filter">The metrics filter.</param>
/// <param name="measureMetricsProvider">The factory used to provide access to metric managers.</param>
/// <param name="metricsBuilder">The factory used to provide access to metric builders.</param>
/// <param name="metricsProvider">The metrics advanced manager factory.</param>
/// <param name="dataManager">The data manager.</param>
/// <param name="metricsManager">The metrics manager.</param>
public DefaultMetrics(
IClock clock,
IFilterMetrics filter,
IMeasureMetrics measureMetricsProvider,
IBuildMetrics metricsBuilder,
IProvideMetrics metricsProvider,
IProvideMetricValues dataManager,
IManageMetrics metricsManager)
{
Clock = clock ?? new StopwatchClock();
Filter = filter ?? new NullMetricsFilter();
Measure = measureMetricsProvider;
Build = metricsBuilder;
Snapshot = dataManager;
Provider = metricsProvider;
Manage = metricsManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultMetrics" /> class.
/// </summary>
/// <param name="clock">The clock.</param>
/// <param name="globalFilter">The global filter.</param>
/// <param name="measureMetricsProvider">The factory used to provide access to metric managers.</param>
/// <param name="metricsBuilder">The factory used to provide access to metric builders.</param>
/// <param name="metricsProvider">The metrics advanced manager factory.</param>
/// <param name="dataManager">The data manager.</param>
/// <param name="metricsManager">The metrics manager.</param>
/// <param name="healthProvider">The health status provider.</param>
public DefaultMetrics(
IClock clock,
IFilterMetrics globalFilter,
IMeasureMetrics measureMetricsProvider,
IBuildMetrics metricsBuilder,
IProvideMetrics metricsProvider,
IProvideMetricValues dataManager,
IManageMetrics metricsManager,
IProvideHealth healthProvider)
{
Clock = clock ?? new StopwatchClock();
GlobalFilter = globalFilter ?? new NoOpMetricsFilter();
Measure = measureMetricsProvider;
Build = metricsBuilder;
Snapshot = dataManager;
Provider = metricsProvider;
Manage = metricsManager;
Health = healthProvider;
}
public MetricInterceptor(IMeasureMetrics measureMetrics)
{
_measureMetrics = measureMetrics;
}
public MetricFactory(IMeasureMetrics measureMetrics)
{
_proxyGenerator = new ProxyGenerator();
_metricInterceptor = new MetricInterceptor(measureMetrics);
}
private TweekManagementRulesDriver(HttpGet getter, TweekManagementRulesDriverSettings settings, ILogger logger = null, IMeasureMetrics metrics = null, IScheduler scheduler = null)
{
logger = logger ?? NullLogger.Instance;
scheduler = scheduler ?? DefaultScheduler.Instance;
var measuredGetter = MeasureAsync <string, HttpResponseMessage>(metrics, "download_latest_header", s => getter(s));
var measuredDownloader = MeasureAsync(metrics, "download_ruleset", (HttpResponseMessage message) => message.ExtractRules());
_pipeline = Observable.Create <Dictionary <string, RuleDefinition> >(async(sub, ct) =>
{
var shouldStop = false;
try
{
while (!shouldStop)
{
var response = await measuredGetter(RULESET_PATH);
var newVersion = response.GetRulesVersion();
LastCheckTime = DateTime.UtcNow;
if (newVersion == CurrentLabel)
{
await Delay(settings.SampleInterval, scheduler);
continue;
}
var ruleset = await measuredDownloader(response);
sub.OnNext(ruleset);
CurrentLabel = newVersion;
}
}
catch (Exception ex)
{
sub.OnError(ex);
shouldStop = true;
}
ct.Register(() => shouldStop = true);
return(() => shouldStop = true);
})
.SubscribeOn(scheduler)
.Catch((Exception exception) =>
{
logger.LogWarning($"Failed to update rules: \r\n{exception}");
return(Observable.Empty <Dictionary <string, RuleDefinition> >()
.Delay(settings.FailureDelay));
})
.Repeat()
.Replay(1);
}
private TweekManagementRulesDriver(HttpGet getter, TweekManagementRulesDriverSettings settings, ILogger logger = null, IMeasureMetrics metrics = null, IScheduler scheduler = null)
{
logger = logger ?? NullLogger.Instance;
scheduler = scheduler ?? DefaultScheduler.Instance;
var measuredGetter = MeasureAsync <string, HttpResponseMessage>(metrics, "download_latest_header", s => getter(s));
var measuredDownloader = MeasureAsync(metrics, "download_ruleset", (HttpResponseMessage message) => message.ExtractRules());
_pipeline = Observable.Create <Dictionary <string, RuleDefinition> >(async(sub, ct) =>
{
try
{
while (!ct.IsCancellationRequested)
{
var versionResponse = await measuredGetter(RULESET_LATEST_VERSION_PATH);
var latestVersion = await versionResponse.Content.ReadAsStringAsync();
LastCheckTime = scheduler.Now.UtcDateTime;
if (latestVersion != CurrentLabel)
{
var rulesetResponse = await getter(RULESET_PATH);
var newVersion = rulesetResponse.GetRulesVersion();
var ruleset = await measuredDownloader(rulesetResponse);
sub.OnNext(ruleset);
CurrentLabel = newVersion;
}
await Delay(settings.SampleInterval, scheduler);
}
}
catch (Exception ex)
{
sub.OnError(ex);
}
})
.SubscribeOn(scheduler)
.Catch((Exception exception) =>
{
logger.LogWarning(exception, "Failed to update rules");
return(Observable.Empty <Dictionary <string, RuleDefinition> >()
.Delay(settings.FailureDelay));
})
.Repeat()
.Replay(1);
}
