private static void AbilityAnalyzer(ILogMetrics data, IEnumerable<LogEntry> log)
{
var abilityNames = log.Where(m => m.ability.name != "").Select(m => m.ability.name).Distinct();
foreach (var name in abilityNames)
{
var metrics = new AbilityMetrics();
var abilityLog = log.Where(m => m.ability.name == name);
var damageLog = abilityLog.DamageEffects();
var healingLog = abilityLog.HealingEffects();
var threatLog = abilityLog.ThreatEffects();
data.AbilityMetrics.Add(metrics);
metrics.Name = name;
metrics.Number = abilityLog.First().ability.number;
metrics.Count = abilityLog.Count();
metrics.MaximumDamage = damageLog.IfEmpty(0, l => l.Max(m => m.result.amount));
metrics.MinimumDamage = damageLog.IfEmpty(0, l => l.Min(m => m.result.amount));
metrics.AverageDamage = damageLog.IfEmpty(0, l => l.Average(m => m.result.amount));
metrics.MaximumHealing = healingLog.IfEmpty(0, l => l.Max(m => m.result.amount));
metrics.MinimumHealing = healingLog.IfEmpty(0, l => l.Min(m => m.result.amount));
metrics.AverageHealing = healingLog.IfEmpty(0, l => l.Average(m => m.result.amount));
metrics.MaximumThreat = threatLog.IfEmpty(0, l => l.Max(m => m.result.amount));
metrics.MinimumThreat = threatLog.IfEmpty(0, l => l.Min(m => m.result.amount));
metrics.AverageThreat = threatLog.IfEmpty(0, l => l.Average(m => m.result.amount));
metrics.CountOfCriticals = abilityLog.Where(m => m.result.isCritical).Count();
}
data.AbilityMetrics = data.AbilityMetrics.OrderByDescending(m => m.Count).ThenBy(m => m.Name).ToList();
}
protected BufferedOutputPlugin(
string systemName,
ILogMetrics metrics,
string path,
int readLimit = 4 * 1024,
int workerCount = 4,
int?memoryBufferLimit = 512,
int?fileBufferLimit = 512 * 16,
double?flushTimeout = 3000,
double?resendTimeout = 5000,
double[] resendIntervals = null,
Encoding encoding = null,
ILoggerFactory loggerFactory = null
)
: base(Path.Combine(path, systemName),
readLimit: readLimit,
workerCount: workerCount,
memoryBufferLimit: memoryBufferLimit,
fileBufferLimit: fileBufferLimit,
flushTimeout: flushTimeout,
resendTimeout: resendTimeout,
resendIntervals: resendIntervals,
encoding: null,
loggerFactory: null)
{
_logger = loggerFactory?.CreateLogger(typeof(BufferedOutputPlugin)) ?? NullLogger.Instance;
_logger.SLT00016_Trace_BufferedOutputPlugin();
_metrics = metrics;
}
protected BufferedOutputPlugin(string systemName, ILogMetrics metrics) : base(Path.Combine("LogBuffer", systemName),
4 * 1024, 4 * 256, 1024 * 16 * 4, 1000, workerCount: 4)
{
_logger = NullLogger.Instance;
_logger.SLT00015_Trace_BufferedOutputPlugin_string_systemName_ILogMetrics_metrics();
_metrics = metrics;
}
private void LogAnalyzer(ILogMetrics data, IEnumerable<LogEntry> log)
{
data.TotalDamage = log.DamageEffects().Sum(m => m.result.amount);
data.TotalHealing = log.HealingEffects().Sum(m => m.result.amount);
data.TotalThreat = log.ThreatEffects().Sum(m => m.threat);
data.CountOfParry = log.ParryEffects().Count();
data.CountOfDeflect = log.DeflectEffects().Count();
AbilityAnalyzer(data, log);
}
public PluginFactory(IConfiguration configuration, ILogMetrics metrics, ILoggerFactory loggerFactory)
{
_metrics = metrics;
_loggerFactory = loggerFactory;
_logger = _loggerFactory.CreateLogger <PluginFactory>();
_logger.SLT00012_Debug_PluginFactory();
try
{
var outputPluginsSection = configuration.GetSection("OutputPlugins");
_bufferSettingsConfig = new BufferSettingsConfig();
var bufferConfiguration = configuration.GetSection("BufferSettings");
if (bufferConfiguration != null)
{
bufferConfiguration.Bind(_bufferSettingsConfig);
}
if (outputPluginsSection == null)
{
return;
}
foreach (var pluginSection in outputPluginsSection.GetChildren())
{
var pluginName = pluginSection["Output"];
var systemName = pluginSection["System"];
if (systemName == null || pluginName == null)
{
continue;
}
_configs[systemName] = CreateOutputPlugin(pluginName, systemName, pluginSection);
}
}
catch (Exception e)
{
_logger.SLT00014_Error_Plugin_not_created(e);
throw e;
}
finally
{
_logger.SLT00011_Debug_PluginFactory_End();
}
}
private static void AbilityAnalyzer(ILogMetrics data, IEnumerable<LogEntry> log)
{
var abilityNames = log.Where(m => m.ability.name != "").Select(m => m.ability.name).Distinct();
foreach (var name in abilityNames)
{
var count = new AbilityMetrics();
var abilityLog = log.Where(m => m.ability.name == name);
data.AbilityCounts.Add(count);
count.Name = name;
count.Number = abilityLog.First().ability.number;
count.Count = abilityLog.Count();
count.MaximumDamage = abilityLog.Max(m => m.result.amount);
count.MinimumDamage = abilityLog.Min(m => m.result.amount);
count.AverageDamage = abilityLog.Average(m => m.result.amount);
count.CountOfCriticals = abilityLog.Where(m => m.result.isCritical).Count();
}
data.AbilityCounts = data.AbilityCounts.OrderByDescending(m => m.Count).ThenBy(m => m.Name).ToList();
}
protected BufferedOutputPlugin(
string systemName,
ILogMetrics metrics,
BufferSettingsConfig settingsConfig = null,
ILoggerFactory loggerFactory = null)
: base(Path.Combine(settingsConfig?.BufferPath ?? "LogBuffer", systemName),
settingsConfig?.ReadLimit ?? 4 * 1024,
settingsConfig?.MemoryBufferLimit,
settingsConfig?.FileBufferLimit,
settingsConfig?.FlushTimeout,
settingsConfig?.ResendTimeout,
settingsConfig?.ResendIntervals,
settingsConfig?.WorkerCount ?? 1,
settingsConfig?.Encoding,
loggerFactory)
{
_logger = loggerFactory?.CreateLogger(typeof(BufferedOutputPlugin)) ?? NullLogger.Instance;
_logger.SLT00017_Trace_BufferedOutputPlugin_BufferSettingsConfig_config(settingsConfig);
_metrics = metrics;
}
public ClickhouseOutputPlugin(ClickhouseOutputConfig outputConfig, ILogMetrics metrics,
ILoggerFactory loggerFactory) : base(
outputConfig.System, metrics, outputConfig?.BufferSettings, loggerFactory)
{
_loggerFactory = loggerFactory;
_logger = _loggerFactory.CreateLogger <ClickhouseOutputPlugin>();
_logger.SLT00018_Debug_ClickhouseOutputPlugin_outputConfig_outputConfig(outputConfig);
_outputConfig = outputConfig;
_metrics = metrics;
_columns = outputConfig.Columns;
var columns = new Dictionary <string, int>();
foreach (var column in outputConfig.Columns)
{
columns[column] = columns.Count;
}
//_insertQuery = $"INSERT INTO {outputConfig.Database}.{outputConfig.Table} ({string.Join(", ", outputConfig.Columns)}) FORMAT Values ";
_insertJsonQuery = $"INSERT INTO {outputConfig.Database}.{outputConfig.Table} FORMAT JSONEachRow ";
//_formatter = new RowFormatter(columns);
var urlBuilder = new UriBuilder("http", outputConfig.Host, outputConfig.Port);
var properties = new Dictionary <string, string>();
if (outputConfig.User != null)
{
properties.Add("user", outputConfig.User);
}
if (outputConfig.Password != null)
{
properties.Add("password", outputConfig.Password);
}
properties.Add("input_format_null_as_default", "1");
_queryUrl = QueryHelpers.AddQueryString(urlBuilder.ToString(), properties);
}
