public static void Run()
{
// [2] Results aggregation (Or raw measurement collection, see RawDataMeasurementsDemo.cs)
// Define how data gets aggregated.
// Dimensions are like GROUP BY keys in SQL
// Metrics are aggregation functions like COUNT, SUM, etc..
// Extensive HistogramAggregator demo now WiP
HistogramAggregator aggregator = new HistogramAggregator()
.Add(new TimeDimension(TimeSpan.FromSeconds(5)))
.Add(new CountMetric())
.Add(new ErrorCountMetric())
.Add(new TransactionsPerSecMetric())
.Add(new PercentileMetric(0.95, 0.99));
// Secondary aggregation just to monitor key metrics.
KpiPrinterAggregator kpiPrinter = new KpiPrinterAggregator(
TimeSpan.FromSeconds(5),
new CountMetric(Checkpoint.NotMeassuredCheckpoints),
new ErrorCountMetric(false),
new TransactionsPerSecMetric()
);
// [3] Execution settings
// Using StrategyBuilder put defined aggregation, scenario, and execution settings into one object
StrategyBuilder strategy = new StrategyBuilder()
.SetAggregator(aggregator, kpiPrinter) // Optional
.SetScenario <BlankScenario>() // Required
.SetLimit(new TimeLimit(TimeSpan.FromSeconds(20))) // Optional, but if not provided, execution will never stop - unless running test with RunAsync() and stopping later with CancelAsync(true)
.SetSpeed(new FixedSpeed(100000)) // Optional (Skip for maximum throughput)
.SetThreading(new FixedThreadCount(4)); // Required
// [4] Execution
// All that's left is Build(), run and wait for completion and print out measured results.
LoadRunnerEngine engine = strategy.Build();
engine.Run();
IEnumerable <object> result = aggregator.BuildResultsObjects();
Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.Indented));
}
public static void Run()
{
HistogramAggregator aggregator = new HistogramAggregator()
.Add(new TimeDimension(TimeSpan.FromSeconds(5)))
.Add(new CountMetric())
.Add(new GlobalTimerPeriodMetric())
.Add(new TransactionsPerSecMetric());
StrategyBuilder strategy = new StrategyBuilder()
.SetScenario <BatchStrategyDemo>()
.AddSpeed(new BatchByTimeIntervalSpeed(TimeSpan.FromSeconds(5), 10))
.SetThreading(new FixedThreadCount(15))
.SetLimit(new TimeLimit(TimeSpan.FromSeconds(20)))
.SetAggregator(aggregator);
strategy.Build().Run();
Console.WriteLine(JsonConvert.SerializeObject(aggregator.BuildResultsObjects(), Formatting.Indented));
}
public void EmptyPolicy_WhenException_Throw(bool isPositive, bool expectedException)
{
var policyRegistry = new StrategyBuilder();
var timesExecuted = 0;
var policy = policyRegistry.Build();
var executionResult = policy.Execute(() =>
{
timesExecuted++;
var num = GetNumber(isPositive);
if (num <= 0)
{
throw new Exception();
}
return(num);
});
Assert.Equal(1, timesExecuted);
Assert.Equal(expectedException, executionResult.Exception != null);
}
public ITypeBuilderStrategy Build(IActionConfiguration actionConfiguration, Type returnType)
{
string key = actionConfiguration.ActionMethodInfo.ToString() + returnType.ToString();
return(StrategyCache.GetCachedOrAdd(key,
() =>
{
var sirenMetadataTypes = actionConfiguration.MetadataProvider.GetRegisteredMetadataTypes().ToList();
Func <CustomAttributeBuilder> jsonPropAttrNullValueHandling = () =>
{
var type = typeof(JsonPropertyAttribute);
var ctor = type.GetConstructor(Type.EmptyTypes);
return new CustomAttributeBuilder(ctor,
new object[] {},
new[] { type.GetProperty("NullValueHandling") }, new object[] { NullValueHandling.Ignore });
};
// Do not use IActionConfiguration from parameter list as configuration might be altered on call
Action <object, object, IActionConfiguration> classNameAssigner =
(proxyObject, originalObject, configuration) =>
{
var classProp = proxyObject.GetType().GetProperty("class");
classProp.SetValue(proxyObject, configuration.Class);
};
var strategyBuilder = new StrategyBuilder()
.For(returnType)
.WithPayloadPropertyStrategy(returnType, "properties")
.WithSimpleAttributedPropertyStrategy(typeof(string[]), "class", new [] { jsonPropAttrNullValueHandling })
.WithSimpleAttributedPropertyStrategy(typeof(string), "href", new[] { jsonPropAttrNullValueHandling })
.WithSimpleAttributedPropertyStrategy(typeof(string[]), "rel", new[] { jsonPropAttrNullValueHandling })
.WithCustomActivationStrategy(classNameAssigner);
sirenMetadataTypes.ForEach(metadataType => strategyBuilder.WithTypedMetadataProperty(metadataType, metadataType.Name.ToLower()));
return strategyBuilder.Build();
}));
}
public static void Run()
{
HistogramAggregator aggregator = new HistogramAggregator()
.Add(new CountMetric())
.Add(new FuncMetric <TimeSpan>("max", TimeSpan.Zero, (s, result) => s < result.IterationStarted ? result.IterationStarted : s));
AssertIterationIdsAggregator idsValidator = new AssertIterationIdsAggregator();
int streamCount = 0;
StreamAggregator streamAggregator = new StreamAggregator(results => streamCount = results.Count());
CountingScenarioFactory factory = new CountingScenarioFactory();
StrategyBuilder strategy = new StrategyBuilder()
.SetScenario(factory)
.SetThreading(new FixedThreadCount(16))
.SetLimit(new TimeLimit(TimeSpan.FromSeconds(12)))
.SetAggregator(aggregator, idsValidator, streamAggregator);
Stopwatch sw = new Stopwatch();
sw.Start();
strategy.Build().Run();
sw.Stop();
Console.WriteLine(JsonConvert.SerializeObject(aggregator.BuildResultsObjects(), Formatting.Indented));
factory.PrintSum();
int expected = factory.GetSum();
int actual = (int)aggregator.BuildResults().Data[0][1];
TimeSpan lastIteration = (TimeSpan)aggregator.BuildResults().Data[0][3];
Console.WriteLine($@"TPS {expected / lastIteration.TotalSeconds:N}");
Console.WriteLine($@"Last iteration ended at: {lastIteration:g}");
Console.WriteLine($@"Aggregator catchup took: {(sw.Elapsed-lastIteration):g}");
Console.WriteLine();
Console.WriteLine($@"{expected}/{actual} & {streamCount} ? {expected==actual} && {expected==streamCount}");
Console.WriteLine();
idsValidator.PrintResults();
}
public ITypeBuilderStrategy Build(IActionConfiguration actionConfiguration, Type returnType)
{
string key = actionConfiguration.ActionMethodInfo.ToString() + returnType.ToString();
return(StrategyCache.GetCachedOrAdd(key,
() =>
{
var rels =
(Dictionary <string, IList <string> >)
actionConfiguration.MetadataProvider.GetMetadataByType(
typeof(Dictionary <string, IList <string> >));
IList <string> topRels = rels.Values.ToList().ConvertAll(c => c.FirstOrDefault());
var strategyBuilder = new StrategyBuilder()
.For(returnType)
.WithSimpleProperties()
.WithPlainRouteInformation(topRels);
return strategyBuilder.Build();
}));
}
public static void Run()
{
HistogramAggregator aggregator = new HistogramAggregator()
.Add(new TimeDimension(TimeSpan.FromSeconds(4)))
.Add(new CountMetric())
.Add(new TransactionsPerSecMetric());
//var kpiAggregator = new KpiPrinterAggregator(
// TimeSpan.FromSeconds(1),
// new MaxDurationMetric(),
// new CountMetric(Checkpoint.NotMeassuredCheckpoints),
// new TransactionsPerSecMetric());
StrategyBuilder strategy = new StrategyBuilder()
.SetScenario(new CountingScenarioFactory())
.SetThreading(new FixedThreadCount(4))
.SetLimit(new TimeLimit(TimeSpan.FromSeconds(13)))
.SetAggregator(aggregator);
strategy.Build().Run();
Console.WriteLine(JsonConvert.SerializeObject(aggregator.BuildResultsObjects(), Formatting.Indented));
}
public static void Run()
{
CountingScenarioFactory scenarioFactory = new CountingScenarioFactory();
StrategyBuilder strategy = new StrategyBuilder()
.SetScenario(scenarioFactory)
.SetThreading(new FixedThreadCount(4))
.SetLimit(new TimeLimit(TimeSpan.FromSeconds(10)));
// Increase TimeLimit precision
LoadRunnerEngine engine = strategy.Build();
engine.HeartBeatMs = 1;
Stopwatch watch = new Stopwatch();
watch.Start();
engine.Run();
watch.Stop();
scenarioFactory.PrintSum();
Console.WriteLine($@"TPS {scenarioFactory.GetSum() / watch.Elapsed.TotalSeconds:N}");
Console.WriteLine(watch.Elapsed.ToString("g"));
}
public static void Run()
{
IEnumerable <IResult> rawResults = null;
StreamAggregator streamAggregator = new StreamAggregator(results => rawResults = results);
HistogramAggregator aggregator = CreateAggregator();
HistogramAggregator aggregagorOriginal = CreateAggregator();
StrategyBuilder strategy = new StrategyBuilder()
.SetScenario <BlankScenario>()
.SetThreading(new FixedThreadCount(3))
.SetLimit(new TimeLimit(TimeSpan.FromSeconds(5)))
.SetAggregator(streamAggregator, aggregagorOriginal);
strategy.Build().Run();
StreamAggregator.Replay(rawResults, aggregator);
Console.WriteLine(@"-------- FROM LIVE AGGREGATION --------");
Console.WriteLine(JsonConvert.SerializeObject(aggregagorOriginal.BuildResultsObjects(), Formatting.Indented));
Console.WriteLine(@"-------- FROM STREAM --------");
Console.WriteLine(JsonConvert.SerializeObject(aggregator.BuildResultsObjects(), Formatting.Indented));
}
public static StrategyBuilder Build(ILoggerFactory loggerFactory)
{
var builder = new StrategyBuilder(loggerFactory);
return(builder);
}
/// <summary>
/// Called when process is starting
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Task StartAsync(CancellationToken cancellationToken)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls13;
string environment = null;
FileConfigurationProvider ProviderForFile(string name) => new FileConfigurationProvider
{
File = name,
Path = environment.IsNullOrEmpty() ? Path.Combine(AppContext.BaseDirectory, $"configs") : Path.Combine(AppContext.BaseDirectory, $"configs", environment),
ReloadOnAccess = false
};
// set active configuration
EnvironmentConfiguration.UseProvider(ProviderForFile("environment.config.json"));
environment = EnvironmentConfiguration.Instance.Environment;
// load custom configurations from file
// Signals core application configuration
ApplicationConfiguration.UseProvider(ProviderForFile("application.config.json"));
// Signals core background application configuration
BackgroundApplicationConfiguration.UseProvider(ProviderForFile("background.application.config.json"));
// Application custom domain configuration
DomainConfiguration.UseProvider(ProviderForFile("domain.config.json"));
// use general exception handling strategy
var strategyBuilder = new StrategyBuilder();
strategyBuilder.Add <Exception>(new RetryStrategy {
RetryCount = 3, RetryCooldown = TimeSpan.FromMinutes(5)
}).SetAutoHandling(false);
// configure Signals aspects
var config = new BackgroundApplicationBootstrapConfiguration
{
// configure dependency injection
RegistrationService = new RegistrationService(),
// recurring task registry
TaskRegistry = new FluentRegistry(),
// configure caching
CacheConfiguration = new InMemoryCacheConfiguration
{
DataProvider = new InMemoryDataProvider(),
ExpirationPolicy = CacheExpirationPolicy.Sliding,
ExpirationTime = TimeSpan.FromMinutes(1)
},
// configure logging in database
LoggerConfiguration = new DatabaseLoggingConfiguration
{
Database = DomainConfiguration.Instance.DatabaseConfiguration.ActiveConfiguration.Database,
Host = DomainConfiguration.Instance.DatabaseConfiguration.ActiveConfiguration.IpAddress,
Username = DomainConfiguration.Instance.DatabaseConfiguration.ActiveConfiguration.Uid,
Password = DomainConfiguration.Instance.DatabaseConfiguration.ActiveConfiguration.Pwd,
DataProvider = DataProvider.SqlClient,
TableName = "LogEntity"
},
// configure localization from json files
LocalizationConfiguration = new JsonDataProviderConfiguration
{
DirectoryPath = Path.Combine(AppContext.BaseDirectory, "system.resources"),
FileExtension = "app",
LocalizationSources = new List <LocalizationSource>
{
new LocalizationSource
{
Name = "Mail messages",
SourcePath = "mailmessages"
},
new LocalizationSource
{
Name = "Validation rules",
SourcePath = "validationrules"
},
new LocalizationSource
{
Name = "Pages",
SourcePath = "pages"
},
new LocalizationSource
{
Name = "Processes",
SourcePath = "processes"
}
}
},
// configure pubsub with MSSQL broker
ChannelConfiguration = new MsSqlChannelConfiguration
{
// make sure broker is enabled in the database
// ex: ALTER DATABASE [acme.db] SET ENABLE_BROKER WITH ROLLBACK IMMEDIATE
ConnectionString = DomainConfiguration.Instance.DatabaseConfiguration.ActiveConfiguration.ConnectionString,
DbTableName = DomainConfiguration.Instance.NotificationConfiguration.DbTableName,
MessageListeningStrategy = MessageListeningStrategy.Broker
},
StrategyBuilder = new StrategyBuilder().SetAutoHandling(false),
};
// set default serialization settings
config.JsonSerializerSettings = new Newtonsoft.Json.JsonSerializerSettings();
config.JsonSerializerSettings.ConfigureForNodaTime(DateTimeZoneProviders.Tzdb);
// bootstrap the configuration from the references assemblies
var assemblies = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "App.*.dll").Select(file => Assembly.LoadFrom(file)).ToArray();
config.Bootstrap(assemblies);
// set current culture and UI culture
Thread.CurrentThread.CurrentCulture = new CultureInfo(DomainConfiguration.Instance.LocalizationConfiguration.DefaultCulture);
Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture;
return(Task.CompletedTask);
}
