public FileProcessor(ILog log, ILogProcessingConfiguration configuration, ILogProcessor logProcessor, ILogEntryGroupBox groupBox)
{
Log = log;
LogProcessor = logProcessor;
GroupBox = groupBox;
Encoding = CodePagesEncodingProvider.Instance.GetEncoding(configuration.Encoding) ?? Encoding.UTF8;
}
public void ProcessingLogs(ILogProcessor processor, FilterLog[] logs)
{
if (IsInfoEnabled)
{
Logger.Info($"Processing Logs. Processor: {processor.GetType().FullName}, Logs: {logs.Length}");
}
}
public static void ProcessSheetWithProcessor(Worksheet sheet, ILogProcessor processor)
{
Sheets sheets = ThisAddIn.app.ActiveWorkbook.Sheets;
// Check if the data chosen was already processed
for (int n = 1; n <= sheets.Count; n++)
{
if (sheets[n].Name == Util.GetProcessedName(sheet.Name))
{
return;
}
}
// Disable UI updates
ThisAddIn.app.ScreenUpdating = false;
bool displayStatusBar = ThisAddIn.app.DisplayStatusBar;
ThisAddIn.app.DisplayStatusBar = false;
XlCalculation calculation = ThisAddIn.app.Calculation;
ThisAddIn.app.Calculation = XlCalculation.xlCalculationManual;
bool enableEvents = ThisAddIn.app.EnableEvents;
ThisAddIn.app.EnableEvents = false;
Worksheet outputSheet = AddSheetForOutput(sheet);
System.Diagnostics.Trace.WriteLine("About to construct FastSheetReader at " + new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds());
FastSheetReader reader = new FastSheetReader(sheet, processor.GetSeparator());
System.Diagnostics.Trace.WriteLine("Finished constructing FastSheetReader at " + new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds());
FastSheetWriter writer = new FastSheetWriter(outputSheet);
System.Diagnostics.Trace.WriteLine("Finished constructing FastSheetWriter at " + new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds());
Util.RunPipeline(reader, processor, writer, true);
System.Diagnostics.Trace.WriteLine("Finished running pipeline at " + new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds());
writer.Flush();
System.Diagnostics.Trace.WriteLine("Flushed writer at " + new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds());
// Tag the sheet with a machine type mark so we don't have to dig into the cell
// data to identify machine type when trying to generate summary statistics
outputSheet.CustomProperties.Add(Util.MACHINE_TYPE_MARK_NAME, processor.GetUniqueTag());
// Re-enable UI updates
ThisAddIn.app.ScreenUpdating = true;
ThisAddIn.app.DisplayStatusBar = displayStatusBar;
ThisAddIn.app.Calculation = calculation;
ThisAddIn.app.EnableEvents = enableEvents;
writer.FormatPretty();
System.Diagnostics.Trace.WriteLine("Finished format pretty at " + new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds());
// Don't AutoFit, as it can be really slow.
outputSheet.Columns.AutoFit();
System.Diagnostics.Trace.WriteLine("Returning at " + new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds());
}
public LogFileReader(IOptions <FileGatewayConfiguration> settings, ILogProcessor logProcessor)
{
_settings = settings.Value;
_logProcessor = logProcessor;
_internalDictionary = new ConcurrentDictionary <string, long>();
Observable.Interval(TimeSpan.FromSeconds(1)).Subscribe(PollFiles);
//_internalWatcher.EnableRaisingEvents = true;
}
public Controller()
{
ConfigurePath();
_logProcessor = new LogProcessor();
_pythonScriptRunner = new PythonScriptRunner(PythonScriptFilePath);
_fileConversionUtility = new FileConversionUtility();
_conceptLattice = new Algorithm();
}
public void AddLoggerMethod1SadPath2()
{
var services = new ServiceCollection();
ILogProcessor logProcessor = null;
Action act = () => services.AddLogger(logProcessor);
act.Should().ThrowExactly <ArgumentNullException>().WithMessage("*logProcessor*");
}
protected ScriptorLogger(string name, IExternalScopeProvider scopeProvider, ILogProcessor logProcessor)
{
_logProcessor = logProcessor ?? throw new ArgumentException("logProcessor cannot be null", nameof(logProcessor));
_scopeProvider = scopeProvider ?? new LoggerExternalScopeProvider();
Name = name ?? throw new ArgumentNullException(nameof(name));
Filter = (category, logLevel) => true;
Compose = ComposeInternal;
}
/// <summary>
/// Initializes a new instance of the <see cref="Logger"/> class.
/// </summary>
/// <param name="logProcessor">The object responsible for processing logs.</param>
/// <param name="name">The name of the logger.</param>
/// <param name="level">The logging level of the logger.</param>
/// <param name="logProviders">A collection of <see cref="ILogProvider"/> objects used by this logger.</param>
/// <param name="isDisabled">A value indicating whether the logger is disabled.</param>
/// <param name="contextProviders">
/// A collection of <see cref="IContextProvider"/> objects that customize outgoing log entries.
/// </param>
public Logger(
ILogProcessor logProcessor,
string name = DefaultName,
LogLevel level = LogLevel.NotSet,
[AlternateName("providers")] IReadOnlyCollection <ILogProvider> logProviders = null,
bool isDisabled = false,
IReadOnlyCollection <IContextProvider> contextProviders = null)
: this(name, level, logProviders, isDisabled, contextProviders, logProcessor, disposeLogProcessor : false)
{
}
public EnquiryController(IEnquiry enquiry, DbContextOptions <ApplicationDbContext> applicationDbContext)
{
_enquiry = enquiry;
_applicationDbContext = new ApplicationDbContext(applicationDbContext);
_logProcessor = new LogProcessor(_applicationDbContext);
_configuration = new ConfigurationRepository(_applicationDbContext);
_irctcUrl = _configuration.FindBy(x => x.key == "IRCTC_ApiURL").FirstOrDefault().value;
_irctc_userName = _configuration.FindBy(x => x.key == "IRCTC_Username").FirstOrDefault().value;
_irctc_password = _configuration.FindBy(x => x.key == "IRCTC_Password").FirstOrDefault().value;
_authInfo = _irctc_userName + ":" + _irctc_password;
}
public BookingController(IBooking booking, DbContextOptions <ApplicationDbContext> applicationDBContext)
{
_booking = booking;
_applicationDbContext = new ApplicationDbContext(applicationDBContext);
_log = new LogProcessor(_applicationDbContext);
_configuration = new ConfigurationRepository(_applicationDbContext);
_irctcUrl = _configuration.FindBy(x => x.key == "IRCTC_ApiURL").FirstOrDefault().value;
_irctc_userName = _configuration.FindBy(x => x.key == "IRCTC_Username").FirstOrDefault().value;
_irctc_password = _configuration.FindBy(x => x.key == "IRCTC_Password").FirstOrDefault().value;
_authInfo = _irctc_userName + ":" + _irctc_password;
_order = new TicketOrdersRepository(_applicationDbContext);
}
public static ILogProcessor GetCorrectProcessorForImportedSheet(Worksheet sheet)
{
// Go through our log processors and return the correct one for this sheet
foreach (LogType logType in Enum.GetValues(typeof(LogType)))
{
ILogProcessor processor = CreateProcessor(logType);
if (processor != null && processor.IsThisLog(sheet))
{
return(processor);
}
}
return(null);
}
public static void RunPipeline(IInputReader reader, ILogProcessor processor, IOutputWriter writer, bool writeHeader)
{
processor.SetWriter(writer);
if (writeHeader)
{
processor.WriteHeader();
}
while (!reader.NoMoreLines())
{
processor.ReadLine(reader.ReadLine());
}
processor.Done();
}
public static void ProcessEntireDirectory(LogType t)
{
String folder;
// Create folder picker
FileDialog fileDialog = ThisAddIn.app.FileDialog[MsoFileDialogType.msoFileDialogFolderPicker];
fileDialog.AllowMultiSelect = false;
if (fileDialog.Show() != -1)
{
return;
}
folder = fileDialog.SelectedItems.Item(1);
// Prevent showing excel document updates to improve performance
ThisAddIn.app.ScreenUpdating = false;
string outputFileName = Path.Combine(folder, "processed_all.csv");
string[] files = Directory.GetFiles(folder, Util.GetFileNamePatternForLog(t));
// Quit if no files found
if (files.Length == 0)
{
System.Windows.Forms.MessageBox.Show("No compatible files found in the selected directory.");
return;
}
// Show progress bar
ProgressBarForm progress = new ProgressBarForm();
progress.InitializeAndShow(files.Length - 1);
FileWriter writer = new FileWriter(outputFileName);
// Loop to process multiple files consecutively
for (int i = 0; i < files.Length; i++)
{
ILogProcessor processor = Util.CreateProcessor(t);
FileReader reader = new FileReader(files[i]);
processor.SetFileName(Path.GetFileName(files[i]));
Util.RunPipeline(reader, processor, writer, writeHeader: i == 0);
progress.Step();
}
writer.Flush();
progress.Done();
System.Windows.Forms.MessageBox.Show("Processed output written to " + outputFileName);
}
public void ConstructorHappyPath()
{
var source = new TestConfigurationSource();
source.Provider.Set("CustomLogger:Level", "Fatal");
var configuration = new ConfigurationBuilder()
.Add(source)
.Build();
var services = new ServiceCollection();
services.Configure <LoggerOptions>("MyLogger", configuration.GetSection("CustomLogger"));
var serviceProvider = services.BuildServiceProvider();
var logProcessor = new Mock <ILogProcessor>().Object;
var name = "MyLogger";
var logProviders = new[] { new Mock <ILogProvider>().Object };
var contextProviders = new[] { new Mock <IContextProvider>().Object };
var optionsMonitor = serviceProvider.GetRequiredService <IOptionsMonitor <LoggerOptions> >();
var options = optionsMonitor.Get("MyLogger");
Action <LoggerOptions> configureOptions = opt => { };
var reloadingLogger = ReloadingLogger.New(logProcessor, name, logProviders, contextProviders, optionsMonitor, options, configureOptions);
string actualName = reloadingLogger.Name;
ILogProcessor actualLogProcessor = reloadingLogger._logProcessor;
IReadOnlyCollection <ILogProvider> actualLogProviders = reloadingLogger._logProviders;
IReadOnlyCollection <IContextProvider> actualContextProviders = reloadingLogger._contextProviders;
Action <LoggerOptions> actualConfigureOptions = reloadingLogger._configureOptions;
actualName.Should().BeSameAs(name);
actualLogProcessor.Should().BeSameAs(logProcessor);
actualLogProviders.Should().BeSameAs(logProviders);
actualContextProviders.Should().BeSameAs(contextProviders);
actualConfigureOptions.Should().BeSameAs(configureOptions);
Logger logger = reloadingLogger._logger;
logger.Name.Should().Be(name);
logger.Level.Should().Be(LogLevel.Fatal);
logger.IsDisabled.Should().BeFalse();
logger.LogProviders.Should().BeSameAs(logProviders);
logger.ContextProviders.Should().BeSameAs(contextProviders);
logger.LogProcessor.Should().BeSameAs(logProcessor);
}
public ReloadingLogger(ILogProcessor logProcessor,
string name,
IReadOnlyCollection <ILogProvider> logProviders,
IReadOnlyCollection <IContextProvider> contextProviders,
IOptionsMonitor <LoggerOptions> optionsMonitor,
LoggerOptions options,
Action <LoggerOptions> configureOptions)
{
Name = name;
_logProcessor = logProcessor;
_logProviders = logProviders;
_contextProviders = contextProviders;
_configureOptions = configureOptions;
_logger = CreateLogger(options);
optionsMonitor.OnChange(OptionsMonitorChanged);
}
public LogTcpReceiver(IOptions <LogTcpSettings> settings, CancellationTokenSource cancellationToken, ILogProcessor logProcessor)
{
_nameTable = new NameTable();
_xmlNamespaceManager = new XmlNamespaceManager(_nameTable);
_context = new XmlParserContext(_nameTable, _xmlNamespaceManager, null, XmlSpace.None);
_xmlReaderSettings = new XmlReaderSettings();
_xmlReaderSettings.ConformanceLevel = ConformanceLevel.Fragment;
_xmlReaderSettings.IgnoreWhitespace = true;
_xmlReaderSettings.IgnoreComments = true;
_xmlReaderSettings.IgnoreProcessingInstructions = true;
_xmlReaderSettings.CheckCharacters = false;
_xmlNamespaceManager.AddNamespace("log4net", "ns");
_settings = settings.Value;
_clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
xsd = GetSchema();
_cancellationToken = cancellationToken.Token;
_logProcessor = logProcessor;
Task.Factory.StartNew(InitSocket);
}
/// <summary>
/// Initializes a new instance of the <see cref="Logger"/> class.
/// </summary>
/// <param name="logProcessor">The object responsible for processing logs.</param>
/// <param name="name">The name of the logger.</param>
/// <param name="level">The logging level of the logger.</param>
/// <param name="logProviders">A collection of <see cref="ILogProvider"/> objects used by this logger.</param>
/// <param name="isDisabled">A value indicating whether the logger is disabled.</param>
/// <param name="contextProviders">
/// A collection of <see cref="IContextProvider"/> objects that customize outgoing log entries.
/// </param>
public Logger(
ILogProcessor logProcessor,
string name = DefaultName,
LogLevel level = LogLevel.NotSet,
[AlternateName("providers")] IReadOnlyCollection <ILogProvider> logProviders = null,
bool isDisabled = false,
IReadOnlyCollection <IContextProvider> contextProviders = null)
{
if (!Enum.IsDefined(typeof(LogLevel), level))
{
throw new ArgumentException($"Log level is not defined: {level}.", nameof(level));
}
Name = name ?? DefaultName;
Level = level;
LogProviders = logProviders ?? _emptyLogProviders;
IsDisabled = isDisabled;
ContextProviders = contextProviders ?? _emptyContextProviders;
LogProcessor = logProcessor ?? throw new ArgumentNullException(nameof(logProcessor));
_canProcessLogs = !IsDisabled && LogProviders.Count > 0;
}
private void ProcessButton_Click(object sender, RibbonControlEventArgs e)
{
switch (e.Control.Id)
{
case "ProcessSingleButton":
Worksheet sheet = ThisAddIn.app.ActiveWorkbook.ActiveSheet;
ILogProcessor processor = Util.GetCorrectProcessorForImportedSheet(sheet);
if (processor != null)
{
Dispatch.ProcessSheetWithProcessor(sheet, processor);
}
else
{
Util.MessageBox("Active worksheet not recognized as a valid log.");
}
break;
case "ProcessAllButton":
List <string> sheetNames = new List <string>();
int processed = 0;
foreach (Worksheet sh in ThisAddIn.app.ActiveWorkbook.Sheets)
{
sheetNames.Add(sh.Name);
}
foreach (string sheetname in sheetNames)
{
Worksheet sheet_ = ThisAddIn.app.ActiveWorkbook.Sheets[sheetname];
ILogProcessor processor_ = Util.GetCorrectProcessorForImportedSheet(sheet_);
if (processor_ != null)
{
Dispatch.ProcessSheetWithProcessor(sheet_, processor_);
processed++;
}
}
Util.MessageBox(processed + " sheet(s) processed.");
break;
}
}
/// <summary>
/// Adds an <see cref="ILogger"/>, along with its associated services, to the specified
/// <see cref="IServiceCollection"/>.
/// </summary>
/// <param name="services">
/// The <see cref="IServiceCollection"/> to add the logger to.
/// </param>
/// <param name="logProcessor">The object that will process log entries on behalf of the logger.</param>
/// <param name="loggerName">The name of the logger to build.</param>
/// <param name="configureOptions">
/// A delegate to configure the <see cref="ILoggerOptions"/> object that is used to configure the
/// logger.
/// </param>
/// <param name="lifetime">The <see cref="ServiceLifetime"/> of the service.</param>
/// <returns>
/// An <see cref="ILoggerBuilder"/> object for adding log providers and context providers.
/// </returns>
/// <remarks>
/// Note that if this method or any of its overloads are called more than once, then the
/// last call defines the log processor for all.
/// </remarks>
public static ILoggerBuilder AddLogger(this IServiceCollection services,
ILogProcessor logProcessor,
string loggerName = Logger.DefaultName,
Action <ILoggerOptions> configureOptions = null,
ServiceLifetime lifetime = ServiceLifetime.Transient)
{
if (services is null)
{
throw new ArgumentNullException(nameof(services));
}
if (logProcessor is null)
{
throw new ArgumentNullException(nameof(logProcessor));
}
var builder = new LoggerBuilder(services, loggerName, configureOptions);
services.SetLogProcessor(logProcessor);
services.Add(new ServiceDescriptor(typeof(ILogger), builder.Build, lifetime));
services.SetLoggerLookupDescriptor();
return(builder);
}
private Logger(
string name,
LogLevel level,
IReadOnlyCollection <ILogProvider> logProviders,
bool isDisabled,
IReadOnlyCollection <IContextProvider> contextProviders,
ILogProcessor logProcessor,
bool disposeLogProcessor)
{
if (!Enum.IsDefined(typeof(LogLevel), level))
{
throw new ArgumentException($"Log level is not defined: {level}.", nameof(level));
}
Name = name ?? DefaultName;
Level = level;
LogProviders = logProviders ?? EmptyLogProviders;
IsDisabled = isDisabled;
ContextProviders = contextProviders ?? EmptyContextProviders;
LogProcessor = logProcessor ?? throw new ArgumentNullException(nameof(logProcessor));
_disposeLogProcessor = disposeLogProcessor;
_canProcessLogs = !IsDisabled && LogProviders.Count > 0;
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="scopeProvider"></param>
/// <param name="logProcessor">ILogProcessorInstance</param>
public JsonLogger(string name, IExternalScopeProvider scopeProvider, ILogProcessor logProcessor) : base(name, scopeProvider, logProcessor)
{
}
public static void ProcessSheetForLogType(Worksheet sheet, LogType t)
{
ILogProcessor processor = Util.CreateProcessor(t);
ProcessSheetWithProcessor(sheet, processor);
}
public LogsMatchedForProcessing(ILogProcessor logProcessor)
{
LogProcessor = logProcessor;
MatchedLogs = new List <FilterLog>();
}
public LogsController(ILogProcessor logProcessor, ILogStorage storage)
{
_logProcessor = logProcessor;
_storage = storage;
}
public LogStructureWithInput Then(ILogProcessor processor)
{
processor.SetContext(_flowStructure.Context);
_flowStructure.Processors.Add(processor);
return(new LogStructureWithInput(_flowStructure));
}
public ILogsProcessorBuilder Add(ILogProcessor processor)
{
Processors.Add(processor);
return(this);
}
private static void SetLogProcessor(this IServiceCollection services, ILogProcessor logProcessor)
{
services.ClearLogProcessor();
services.AddSingleton(logProcessor);
}
public ContinuousFileProcessor(ILog log, ILogProcessingConfiguration configuration, ILogProcessor logProcessor, ILogEntryGroupBox groupBox)
: base(log, configuration, logProcessor, groupBox)
{
worker = new Thread(Thread_Job);
worker.Start();
}
public LogProcessor(ILogProcessor processor, IEnricher enricher)
{
_processor = processor;
_enricher = enricher;
}
public LogStructureWithInput Then(ILogProcessor processor)
{
processor.SetContext(_flowStructure.Context);
_flowStructure.Processors.Add(processor);
return new LogStructureWithInput(_flowStructure);
}
public static void AddLogProcessor(ILogProcessor processor)
{
_logProcessors.Add(processor);
}
public LogPacketHandler(ILogProcessor logProcessor)
{
_logProcessor = logProcessor;
}