public PreprocessingStepsFactory(
Workspaces.IWorkspacesManager workspacesManager,
AppLaunch.ILaunchUrlParser appLaunch,
ISynchronizationContext invoke,
IExtensionsRegistry extentions,
Progress.IProgressAggregator progressAggregator,
Persistence.IWebContentCache cache,
ICredentialsCache credCache,
ILogProviderFactoryRegistry logProviderFactoryRegistry,
WebViewTools.IWebViewTools webBrowserDownloader,
ILogsDownloaderConfig logsDownloaderConfig,
RegularExpressions.IRegexFactory regexFactory,
LogMedia.IFileSystem fileSystem
)
{
this.workspacesManager = workspacesManager;
this.appLaunch = appLaunch;
this.invoke = invoke;
this.extentions = extentions;
this.progressAggregator = progressAggregator;
this.cache = cache;
this.credCache = credCache;
this.logProviderFactoryRegistry = logProviderFactoryRegistry;
this.webViewTools = webBrowserDownloader;
this.logsDownloaderConfig = logsDownloaderConfig;
this.regexFactory = regexFactory;
this.fileSystem = fileSystem;
}
public Factory(
IAlertPopup alerts,
IFileDialogs fileDialogs,
Help.IPresenter help,
ILogProviderFactoryRegistry registry,
IFormatDefinitionsRepository repo,
IUserDefinedFormatsManager userDefinedFormatsManager,
ITempFilesManager tempFilesManager,
ITraceSourceFactory traceSourceFactory,
RegularExpressions.IRegexFactory regexFactory,
LogViewer.IPresenterFactory logViewerPresenterFactory,
IViewsFactory viewFactories,
ISynchronizationContext synchronizationContext,
FieldsProcessor.IFactory fieldsProcessorFactory,
LogMedia.IFileSystem fileSystem
)
{
this.viewFactories = viewFactories;
this.alerts = alerts;
this.registry = registry;
this.fileDialogs = fileDialogs;
this.userDefinedFormatsManager = userDefinedFormatsManager;
this.help = help;
this.repo = repo;
this.tempFilesManager = tempFilesManager;
this.logViewerPresenterFactory = logViewerPresenterFactory;
this.traceSourceFactory = traceSourceFactory;
this.regexFactory = regexFactory;
this.synchronizationContext = synchronizationContext;
this.fieldsProcessorFactory = fieldsProcessorFactory;
this.fileSystem = fileSystem;
}
public Presenter(
IView view,
ITempFilesManager tempFilesManager,
ITraceSourceFactory traceSourceFactory,
RegularExpressions.IRegexFactory regexFactory,
LogViewer.IPresenterFactory logViewerPresenterFactory,
ISynchronizationContext synchronizationContext,
LogMedia.IFileSystem fileSystem
)
{
this.view = view;
this.view.SetEventsHandler(this);
this.tempFilesManager = tempFilesManager;
this.traceSourceFactory = traceSourceFactory;
this.regexFactory = regexFactory;
this.synchronizationContext = synchronizationContext;
this.fileSystem = fileSystem;
this.threads = new ModelThreads();
this.logSourceThreads = new LogSourceThreads(
LJTraceSource.EmptyTracer, threads, null);
this.model = new Presenters.LogViewer.DummyModel();
this.logPresenter = logViewerPresenterFactory.CreateIsolatedPresenter(model, view.LogViewer);
logPresenter.ShowTime = true;
logPresenter.EmptyViewMessageAllowed = false;
}
public FormatAutodetect(Func <ILogProviderFactory, int> mruIndexGetter, ILogProviderFactoryRegistry factoriesRegistry,
ITraceSourceFactory traceSourceFactory, LogMedia.IFileSystem fileSystem)
{
this.mruIndexGetter = mruIndexGetter;
this.factoriesRegistry = factoriesRegistry;
this.traceSourceFactory = traceSourceFactory;
this.fileSystem = fileSystem;
}
public LogSourceRecord(ILogSource logSource, LogSourceMetadata metadata, LogMedia.IFileSystem fileSystem)
{
this.fileSystem = fileSystem;
this.logSource = logSource;
this.metadata = metadata;
this.logFileName = logSource.Provider.ConnectionParams[ConnectionParamsKeys.PathConnectionParam];
this.cancellation = new CancellationTokenSource();
}
public PostprocessorsManager(
ILogSourcesManager logSources,
Telemetry.ITelemetryCollector telemetry,
ISynchronizationContext modelSyncContext,
ISynchronizationContext threadPoolSyncContext,
IHeartBeatTimer heartbeat,
Progress.IProgressAggregator progressAggregator,
Settings.IGlobalSettingsAccessor settingsAccessor,
IOutputDataDeserializer outputDataDeserializer,
ITraceSourceFactory traceSourceFactory,
ILogPartTokenFactories logPartTokenFactories,
Correlation.ISameNodeDetectionTokenFactories sameNodeDetectionTokenFactories,
IChangeNotification changeNotification,
LogMedia.IFileSystem logFileSystem
)
{
this.logSources = logSources;
this.telemetry = telemetry;
this.progressAggregator = progressAggregator;
this.settingsAccessor = settingsAccessor;
this.modelSyncContext = modelSyncContext;
this.threadPoolSyncContext = threadPoolSyncContext;
this.heartbeat = heartbeat;
this.outputDataDeserializer = outputDataDeserializer;
this.logPartTokenFactories = logPartTokenFactories;
this.sameNodeDetectionTokenFactories = sameNodeDetectionTokenFactories;
this.changeNotification = changeNotification;
this.logFileSystem = logFileSystem;
this.tracer = traceSourceFactory.CreateTraceSource("App", "ppm");
this.updater = new AsyncInvokeHelper(modelSyncContext, Refresh);
logSources.OnLogSourceAdded += (sender, args) => updater.Invoke();
logSources.OnLogSourceRemoved += (sender, args) => updater.Invoke();
logSources.OnLogSourceAnnotationChanged += (sender, args) => updater.Invoke();
logSources.OnLogSourceStatsChanged += (object sender, LogSourceStatsEventArgs e) =>
{
if ((e.Flags & LogProviderStatsFlag.ContentsEtag) != 0)
{
updater.Invoke();
}
};
this.visiblePostprocessorsOutputs = Selectors.Create(
() => postprocessorsOutputs,
() => logSources.Items,
(outputs, sources) => {
var sourcesMap = sources.ToLookup(s => s);
return(ImmutableArray.CreateRange(outputs.Where(output => sourcesMap.Contains(output.LogSource))));
}
);
Refresh();
}
public RollingFilesMedia(
LogMedia.IFileSystem fileSystem,
Type logReaderType,
StreamBasedFormatInfo logFormatInfo,
LJTraceSource traceSource,
IRollingFilesMediaStrategy rollingStrategy,
ITempFilesManager tempFilesManager,
ITraceSourceFactory traceSourceFactory)
{
this.traceSourceFactory = traceSourceFactory;
trace = traceSource;
using (trace.NewFrame)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
this.rollingStrategy = rollingStrategy;
this.logReaderType = logReaderType;
this.logFormatInfo = logFormatInfo;
this.tempFilesManager = tempFilesManager;
try
{
this.fileSystem = fileSystem;
this.baseDirectory = rollingStrategy.BaseDirectory;
trace.Info("Base file directory: {0}", baseDirectory);
this.concatStream = new ConcatReadingStream();
this.tempThreads = new LogSourceThreads(LJTraceSource.EmptyTracer, new ModelThreads(), null);
this.fsWatcher = fileSystem.CreateWatcher();
this.fsWatcher.Path = this.baseDirectory;
this.fsWatcher.Created += new FileSystemEventHandler(fsWatcher_Created);
this.fsWatcher.Renamed += new RenamedEventHandler(fsWatcher_Renamed);
this.fsWatcher.EnableRaisingEvents = true;
trace.Info("Watcher enabled");
this.folderNeedsRescan = 1;
}
catch
{
trace.Error("Initialization failed. Disposing.");
Dispose();
throw;
}
}
}
internal TimeAnomalyFixingStep(
PreprocessingStepParams srcFile,
Progress.IProgressAggregator progressAggregator,
ILogProviderFactoryRegistry logProviderFactoryRegistry,
IStepsFactory preprocessingStepsFactory,
RegularExpressions.IRegexFactory regexFactory,
LogMedia.IFileSystem fileSystem)
{
this.@params = srcFile;
this.preprocessingStepsFactory = preprocessingStepsFactory;
this.progressAggregator = progressAggregator;
this.logProviderFactoryRegistry = logProviderFactoryRegistry;
this.regexFactory = regexFactory;
this.fileSystem = fileSystem;
}
public Model(
ISynchronizationContext threadSync,
IChangeNotification changeNotification,
Persistence.IWebContentCache webCache,
Persistence.IContentCache contentCache,
Persistence.IStorageManager storageManager,
IBookmarks bookmarks,
ILogSourcesManager sourcesManager,
IModelThreads threads,
ITempFilesManager tempFilesManager,
Preprocessing.IModel preprocessingModel,
Progress.IProgressAggregator progressAggregator,
ILogProviderFactoryRegistry logProviderFactoryRegistry,
IUserDefinedFormatsManager userDefinedFormatsManager,
MRU.IRecentlyUsedEntities mru,
Progress.IProgressAggregatorFactory progressAggregatorsFactory,
IShutdown shutdown,
WebViewTools.IWebViewTools webViewTools,
Postprocessing.IModel postprocessingModel,
IPluginsManager pluginsManager,
ITraceSourceFactory traceSourceFactory,
LogMedia.IFileSystem fileSystem
)
{
this.SynchronizationContext = threadSync;
this.ChangeNotification = changeNotification;
this.WebContentCache = webCache;
this.ContentCache = contentCache;
this.StorageManager = storageManager;
this.Bookmarks = bookmarks;
this.SourcesManager = sourcesManager;
this.Threads = threads;
this.TempFilesManager = tempFilesManager;
this.Preprocessing = preprocessingModel;
this.ProgressAggregator = progressAggregator;
this.LogProviderFactoryRegistry = logProviderFactoryRegistry;
this.UserDefinedFormatsManager = userDefinedFormatsManager;
this.ProgressAggregatorsFactory = progressAggregatorsFactory;
this.MRU = mru;
this.Shutdown = shutdown;
this.WebViewTools = webViewTools;
this.Postprocessing = postprocessingModel;
this.PluginsManager = pluginsManager;
this.TraceSourceFactory = traceSourceFactory;
this.FileSystem = fileSystem;
}
public LogSourcesManager(
IHeartBeatTimer heartbeat,
ISynchronizationContext invoker,
IModelThreadsInternal threads,
ITempFilesManager tempFilesManager,
Persistence.IStorageManager storageManager,
IBookmarks bookmarks,
Settings.IGlobalSettingsAccessor globalSettingsAccess,
MRU.IRecentlyUsedEntities recentlyUsedEntities,
IShutdown shutdown,
ITraceSourceFactory traceSourceFactory,
IChangeNotification changeNotification,
RegularExpressions.IRegexFactory regexFactory,
LogMedia.IFileSystem fileSystem
) : this(heartbeat, recentlyUsedEntities, shutdown, traceSourceFactory, changeNotification,
new LogSourceFactory(threads, bookmarks, invoker, storageManager, tempFilesManager, globalSettingsAccess, traceSourceFactory, regexFactory, fileSystem))
{
}
public RollingFilesMedia(
LogMedia.IFileSystem fileSystem,
Func <MediaBasedReaderParams, IPositionedMessagesReader> readerCreator,
LJTraceSource traceSource,
IRollingFilesMediaStrategy rollingStrategy)
{
trace = traceSource;
using (trace.NewFrame)
{
if (fileSystem == null)
{
throw new ArgumentNullException(nameof(fileSystem));
}
this.rollingStrategy = rollingStrategy;
this.readerCreator = readerCreator;
try
{
this.fileSystem = fileSystem;
this.baseDirectory = rollingStrategy.BaseDirectory;
trace.Info("Base file directory: {0}", baseDirectory);
this.concatStream = new ConcatReadingStream();
this.tempThreads = new LogSourceThreads(LJTraceSource.EmptyTracer, new ModelThreads(), null);
this.fsWatcher = fileSystem.CreateWatcher();
this.fsWatcher.Path = this.baseDirectory;
this.fsWatcher.Created += new FileSystemEventHandler(fsWatcher_Created);
this.fsWatcher.Renamed += new RenamedEventHandler(fsWatcher_Renamed);
this.fsWatcher.EnableRaisingEvents = true;
trace.Info("Watcher enabled");
this.folderNeedsRescan = 1;
}
catch
{
trace.Error("Initialization failed. Disposing.");
Dispose();
throw;
}
}
}
public LogSourceFactory(
IModelThreadsInternal threads,
IBookmarks bookmarks,
ISynchronizationContext invoker,
Persistence.IStorageManager storageManager,
ITempFilesManager tempFilesManager,
Settings.IGlobalSettingsAccessor globalSettingsAccess,
ITraceSourceFactory traceSourceFactory,
RegularExpressions.IRegexFactory regexFactory,
LogMedia.IFileSystem fileSystem
)
{
this.threads = threads;
this.bookmarks = bookmarks;
this.invoker = invoker;
this.storageManager = storageManager;
this.tempFilesManager = tempFilesManager;
this.globalSettingsAccess = globalSettingsAccess;
this.traceSourceFactory = traceSourceFactory;
this.regexFactory = regexFactory;
this.fileSystem = fileSystem;
}
public LogSource(ILogSourcesManagerInternal owner, int id,
ILogProviderFactory providerFactory, IConnectionParams connectionParams,
IModelThreadsInternal threads, ITempFilesManager tempFilesManager, Persistence.IStorageManager storageManager,
ISynchronizationContext modelSyncContext, Settings.IGlobalSettingsAccessor globalSettingsAccess, IBookmarks bookmarks,
ITraceSourceFactory traceSourceFactory, RegularExpressions.IRegexFactory regexFactory, LogMedia.IFileSystem fileSystem)
{
this.owner = owner;
this.tracer = traceSourceFactory.CreateTraceSource("LogSource", string.Format("ls{0:D2}", id));
this.tempFilesManager = tempFilesManager;
this.modelSyncContext = modelSyncContext;
this.globalSettingsAccess = globalSettingsAccess;
this.bookmarks = bookmarks;
this.traceSourceFactory = traceSourceFactory;
this.regexFactory = regexFactory;
this.fileSystem = fileSystem;
try
{
this.logSourceThreads = new LogSourceThreads(this.tracer, threads, this);
this.timeGaps = new TimeGapsDetector(tracer, modelSyncContext, new LogSourceGapsSource(this), traceSourceFactory);
this.timeGaps.OnTimeGapsChanged += timeGaps_OnTimeGapsChanged;
this.logSourceSpecificStorageEntry = CreateLogSourceSpecificStorageEntry(providerFactory, connectionParams, storageManager);
var extendedConnectionParams = connectionParams.Clone(true);
this.LoadPersistedSettings(extendedConnectionParams);
this.provider = providerFactory.CreateFromConnectionParams(this, extendedConnectionParams);
}
catch (Exception e)
{
tracer.Error(e, "Failed to initialize log source");
((ILogSource)this).Dispose();
throw;
}
this.owner.Add(this);
this.owner.FireOnLogSourceAdded(this);
this.LoadBookmarks();
}
static async Task <DetectedFormat> DetectFormat(
string fileName,
string loggableName,
Func <ILogProviderFactory, int> mruIndexGetter,
ILogProviderFactoryRegistry factoriesRegistry,
CancellationToken cancellation,
IFormatAutodetectionProgress progress,
ITraceSourceFactory traceSourceFactory,
LogMedia.IFileSystem fileSystem)
{
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentException("fileName");
}
if (mruIndexGetter == null)
{
throw new ArgumentNullException("mru");
}
Func <Task <SimpleFileMedia> > createFileMedia = () => SimpleFileMedia.Create(fileSystem, SimpleFileMedia.CreateConnectionParamsFromFileName(fileName));
var log = traceSourceFactory.CreateTraceSource("App", string.Format("fdtc.{0}", Interlocked.Increment(ref lastPerfOp)));
using (new Profiling.Operation(log, string.Format("format detection of {0}", loggableName)))
using (ILogSourceThreadsInternal threads = new LogSourceThreads())
using (var localCancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellation))
{
var candidateFactories = GetOrderedListOfRelevantFactories(fileName, mruIndexGetter, factoriesRegistry).ToArray();
var ret = (await Task.WhenAll(candidateFactories.Select((factory, index) => (factory, index)).Select(async candidate =>
{
var(factory, idx) = candidate;
try
{
using (var perfOp = new Profiling.Operation(log, factory.ToString()))
using (var fileMedia = await createFileMedia())
using (var reader = ((IMediaBasedReaderFactory)factory).CreateMessagesReader(
new MediaBasedReaderParams(threads, fileMedia,
MessagesReaderFlags.QuickFormatDetectionMode, parentLoggingPrefix: log.Prefix)))
{
if (progress != null)
{
progress.Trying(factory);
}
if (localCancellation.IsCancellationRequested)
{
perfOp.Milestone("cancelled");
return(fmt: (DetectedFormat)null, idx);
}
await reader.UpdateAvailableBounds(false);
perfOp.Milestone("bounds detected");
var parser = await reader.CreateParser(new CreateParserParams(0, null,
MessagesParserFlag.DisableMultithreading | MessagesParserFlag.DisableDejitter, MessagesParserDirection.Forward));
try
{
if (await parser.ReadNext() != null)
{
log.Info("Autodetected format of {0}: {1}", fileName, factory);
localCancellation.Cancel();
return(fmt: new DetectedFormat(factory, ((IFileBasedLogProviderFactory)factory).CreateParams(fileName)), idx);
}
}
finally
{
await parser.Dispose();
}
}
}
catch (Exception e)
{
log.Error(e, "Failed to load '{0}' as {1}", fileName, factory);
}
return(fmt: (DetectedFormat)null, idx);
}))).Where(x => x.fmt != null).OrderBy(x => x.idx).Select(x => x.fmt).FirstOrDefault();
if (ret != null)
{
return(ret);
}
using (var fileMedia = await createFileMedia())
{
if (!await IOUtils.IsBinaryFile(fileMedia.DataStream))
{
log.Info("File does not look binary");
var factory = factoriesRegistry.Find(
PlainText.Factory.CompanyName, PlainText.Factory.FormatName) as IFileBasedLogProviderFactory;
if (factory != null)
{
log.Info("Fall back to plaintext format");
return(new DetectedFormat(factory, factory.CreateParams(fileName)));
}
}
}
}
return(null);
}
public FormatAutodetect(IRecentlyUsedEntities recentlyUsedLogs, ILogProviderFactoryRegistry factoriesRegistry, ITraceSourceFactory traceSourceFactory, LogMedia.IFileSystem fileSystem) :
this(recentlyUsedLogs.MakeFactoryMRUIndexGetter(), factoriesRegistry, traceSourceFactory, fileSystem)
{
}
public static ModelObjects Create(
ModelConfig config,
ISynchronizationContext modelSynchronizationContext,
Func <Persistence.IStorageManager, Preprocessing.ICredentialsCache> createPreprocessingCredentialsCache,
Func <IShutdownSource, Persistence.IWebContentCache, ITraceSourceFactory, WebViewTools.IWebViewTools> createWebBrowserDownloader,
Drawing.IMatrixFactory matrixFactory,
RegularExpressions.IRegexFactory regexFactory
)
{
ITraceSourceFactory traceSourceFactory = new TraceSourceFactory(config.TraceListeners, config.RemoveDefaultTraceListener);
IShutdownSource shutdown = new Shutdown();
var tracer = traceSourceFactory.CreateTraceSource("App", "model");
Telemetry.UnhandledExceptionsReporter.SetupLogging(tracer, shutdown);
LogMedia.IFileSystem fileSystem = config.FileSystem ?? LogMedia.FileSystemImpl.Instance;
ILogProviderFactoryRegistry logProviderFactoryRegistry = new LogProviderFactoryRegistry();
IFormatDefinitionsRepository formatDefinitionsRepository = config.FormatsRepositoryAssembly != null ?
(IFormatDefinitionsRepository) new ResourcesFormatsRepository(config.FormatsRepositoryAssembly) :
new DirectoryFormatsRepository(null, config.AdditionalFormatDirectories);
MultiInstance.IInstancesCounter instancesCounter = config.DisableLogjointInstancesCounting ?
(MultiInstance.IInstancesCounter) new MultiInstance.DummyInstancesCounter() :
(MultiInstance.IInstancesCounter) new MultiInstance.InstancesCounter(shutdown);
ITempFilesManager tempFilesManager = new TempFilesManager(traceSourceFactory, instancesCounter);
Persistence.Implementation.IStorageManagerImplementation userDataStorage = new Persistence.Implementation.StorageManagerImplementation();
Persistence.IStorageManager storageManager = new Persistence.PersistentUserDataManager(traceSourceFactory, userDataStorage, shutdown);
Persistence.Implementation.IFileSystemAccess persistentUserDataFileSystem =
config.PersistenceFileSystem ?? Persistence.Implementation.DesktopFileSystemAccess.CreatePersistentUserDataFileSystem(config.AppDataDirectory);
Settings.IGlobalSettingsAccessor globalSettingsAccessor = new Settings.GlobalSettingsAccessor(storageManager);
userDataStorage.Init(
new Persistence.Implementation.RealTimingAndThreading(),
persistentUserDataFileSystem,
new Persistence.PersistentUserDataManager.ConfigAccess(globalSettingsAccessor)
);
Telemetry.ITelemetryUploader telemetryUploader = new Telemetry.AzureTelemetryUploader(
traceSourceFactory,
config.TelemetryUrl,
config.IssuesUrl
);
var telemetryCollectorImpl = new Telemetry.TelemetryCollector(
storageManager,
telemetryUploader,
modelSynchronizationContext,
instancesCounter,
shutdown,
new MemBufferTraceAccess(),
traceSourceFactory
);
Telemetry.ITelemetryCollector telemetryCollector = telemetryCollectorImpl;
FieldsProcessor.IFactory fieldsProcessorFactory = new FieldsProcessor.FieldsProcessorImpl.Factory(
storageManager, telemetryCollector, config.FieldsProcessorMetadataReferencesProvider, config.FieldsProcessorAssemblyLoader);
UserDefinedFormatsManager userDefinedFormatsManager = new UserDefinedFormatsManager(
formatDefinitionsRepository, logProviderFactoryRegistry, tempFilesManager, traceSourceFactory, regexFactory, fieldsProcessorFactory);
RegisterUserDefinedFormats(userDefinedFormatsManager);
RegisterPredefinedFormatFactories(logProviderFactoryRegistry, tempFilesManager, userDefinedFormatsManager, regexFactory, traceSourceFactory);
ISynchronizationContext threadPoolSynchronizationContext = new ThreadPoolSynchronizationContext();
IChangeNotification changeNotification = new ChangeNotification(modelSynchronizationContext);
IFiltersFactory filtersFactory = new FiltersFactory(changeNotification, regexFactory);
IBookmarksFactory bookmarksFactory = new BookmarksFactory(changeNotification);
var bookmarks = bookmarksFactory.CreateBookmarks();
Persistence.IFirstStartDetector firstStartDetector = persistentUserDataFileSystem as Persistence.IFirstStartDetector;
Persistence.Implementation.IStorageManagerImplementation contentCacheStorage = new Persistence.Implementation.StorageManagerImplementation();
contentCacheStorage.Init(
new Persistence.Implementation.RealTimingAndThreading(),
Persistence.Implementation.DesktopFileSystemAccess.CreateCacheFileSystemAccess(config.AppDataDirectory),
new Persistence.ContentCacheManager.ConfigAccess(globalSettingsAccessor)
);
Persistence.IContentCache contentCache = new Persistence.ContentCacheManager(traceSourceFactory, contentCacheStorage);
Persistence.IWebContentCacheConfig webContentCacheConfig = config.WebContentCacheConfig;
Preprocessing.ILogsDownloaderConfig logsDownloaderConfig = config.LogsDownloaderConfig;
Persistence.IWebContentCache webContentCache = new Persistence.WebContentCache(
contentCache,
webContentCacheConfig
);
IHeartBeatTimer heartBeatTimer = new HeartBeatTimer();
Progress.IProgressAggregatorFactory progressAggregatorFactory = new Progress.ProgressAggregator.Factory(heartBeatTimer, modelSynchronizationContext);
Progress.IProgressAggregator progressAggregator = progressAggregatorFactory.CreateProgressAggregator();
var threadColorsLease = new ColorLease(1);
IModelThreadsInternal modelThreads = new ModelThreads(threadColorsLease);
MRU.IRecentlyUsedEntities recentlyUsedLogs = new MRU.RecentlyUsedEntities(
storageManager,
logProviderFactoryRegistry,
telemetryCollector
);
ILogSourcesManager logSourcesManager = new LogSourcesManager(
heartBeatTimer,
modelSynchronizationContext,
modelThreads,
tempFilesManager,
storageManager,
bookmarks,
globalSettingsAccessor,
recentlyUsedLogs,
shutdown,
traceSourceFactory,
changeNotification,
regexFactory,
fileSystem
);
telemetryCollectorImpl.SetLogSourcesManager(logSourcesManager);
Telemetry.UnhandledExceptionsReporter.Setup(telemetryCollector, shutdown);
IFormatAutodetect formatAutodetect = new FormatAutodetect(
recentlyUsedLogs,
logProviderFactoryRegistry,
traceSourceFactory,
fileSystem
);
Workspaces.Backend.IBackendAccess workspacesBackendAccess = new Workspaces.Backend.AzureWorkspacesBackend(
traceSourceFactory,
config.WorkspacesUrl
);
Workspaces.IWorkspacesManager workspacesManager = new Workspaces.WorkspacesManager(
logSourcesManager,
logProviderFactoryRegistry,
storageManager,
workspacesBackendAccess,
tempFilesManager,
recentlyUsedLogs,
shutdown,
traceSourceFactory
);
AppLaunch.ILaunchUrlParser launchUrlParser = new AppLaunch.LaunchUrlParser();
Preprocessing.IExtensionsRegistry preprocessingManagerExtensionsRegistry =
new Preprocessing.PreprocessingManagerExtentionsRegistry(logsDownloaderConfig);
Preprocessing.ICredentialsCache preprocessingCredentialsCache = createPreprocessingCredentialsCache(
storageManager
);
WebViewTools.IWebViewTools webBrowserDownloader = createWebBrowserDownloader(shutdown, webContentCache, traceSourceFactory);
Preprocessing.IStepsFactory preprocessingStepsFactory = new Preprocessing.PreprocessingStepsFactory(
workspacesManager,
launchUrlParser,
modelSynchronizationContext,
preprocessingManagerExtensionsRegistry,
progressAggregator,
webContentCache,
preprocessingCredentialsCache,
logProviderFactoryRegistry,
webBrowserDownloader,
logsDownloaderConfig,
regexFactory,
fileSystem
);
Preprocessing.IManager logSourcesPreprocessings = new Preprocessing.LogSourcesPreprocessingManager(
modelSynchronizationContext,
formatAutodetect,
preprocessingManagerExtensionsRegistry,
new Preprocessing.BuiltinStepsExtension(preprocessingStepsFactory),
telemetryCollector,
tempFilesManager,
logSourcesManager,
shutdown,
traceSourceFactory,
changeNotification
);
ISearchManager searchManager = new SearchManager(
logSourcesManager,
progressAggregatorFactory,
modelSynchronizationContext,
globalSettingsAccessor,
telemetryCollector,
changeNotification,
traceSourceFactory
);
IUserDefinedSearches userDefinedSearches = new UserDefinedSearchesManager(storageManager, filtersFactory, modelSynchronizationContext);
ISearchHistory searchHistory = new SearchHistory(storageManager.GlobalSettingsEntry, userDefinedSearches);
IBookmarksController bookmarksController = new BookmarkController(
bookmarks,
modelThreads,
heartBeatTimer,
modelSynchronizationContext
);
IFiltersManager filtersManager = new FiltersManager(
filtersFactory,
globalSettingsAccessor,
logSourcesManager,
shutdown
);
Postprocessing.IUserNamesProvider analyticsShortNames = new Postprocessing.CodenameUserNamesProvider(
logSourcesManager
);
Postprocessing.TimeSeries.ITimeSeriesTypesAccess timeSeriesTypesAccess = new Postprocessing.TimeSeries.TimeSeriesTypesLoader();
Postprocessing.ILogPartTokenFactories logPartTokenFactories = new Postprocessing.LogPartTokenFactories();
Postprocessing.Correlation.ISameNodeDetectionTokenFactories sameNodeDetectionTokenFactories = new Postprocessing.Correlation.SameNodeDetectionTokenFactories();
Postprocessing.IManagerInternal postprocessorsManager = new Postprocessing.PostprocessorsManager(
logSourcesManager,
telemetryCollector,
modelSynchronizationContext,
threadPoolSynchronizationContext,
heartBeatTimer,
progressAggregator,
globalSettingsAccessor,
new Postprocessing.OutputDataDeserializer(timeSeriesTypesAccess, logPartTokenFactories, sameNodeDetectionTokenFactories),
traceSourceFactory,
logPartTokenFactories,
sameNodeDetectionTokenFactories,
changeNotification,
fileSystem
);
Postprocessing.Correlation.ICorrelationManager correlationManager = new Postprocessing.Correlation.CorrelationManager(
postprocessorsManager,
() => new LogJoint.Postprocessing.Correlation.EmbeddedSolver.EmbeddedSolver(),
modelSynchronizationContext,
logSourcesManager,
changeNotification,
telemetryCollector
);
Postprocessing.IModel postprocessingModel = new Postprocessing.Model(
postprocessorsManager,
timeSeriesTypesAccess,
new Postprocessing.StateInspector.Model(tempFilesManager, logPartTokenFactories),
new Postprocessing.Timeline.Model(tempFilesManager, logPartTokenFactories),
new Postprocessing.SequenceDiagram.Model(tempFilesManager, logPartTokenFactories),
new Postprocessing.TimeSeries.Model(timeSeriesTypesAccess),
new Postprocessing.Correlation.Model(tempFilesManager, logPartTokenFactories, sameNodeDetectionTokenFactories)
);
AutoUpdate.IFactory autoUpdateFactory = new AutoUpdate.Factory(
tempFilesManager,
traceSourceFactory,
instancesCounter,
shutdown,
modelSynchronizationContext,
firstStartDetector,
telemetryCollector,
storageManager,
changeNotification,
config.AutoUpdateUrl,
config.PluginsUrl
);
AppLaunch.ICommandLineHandler commandLineHandler = new AppLaunch.CommandLineHandler(
logSourcesPreprocessings,
preprocessingStepsFactory);
Postprocessing.IAggregatingLogSourceNamesProvider logSourceNamesProvider = new Postprocessing.AggregatingLogSourceNamesProvider();
Postprocessing.InternalTracePostprocessors.Register(
postprocessorsManager,
userDefinedFormatsManager,
timeSeriesTypesAccess,
postprocessingModel
);
Extensibility.IPluginsManagerInternal pluginsManager = new Extensibility.PluginsManager(
traceSourceFactory,
telemetryCollector,
shutdown,
userDefinedFormatsManager,
autoUpdateFactory.CreatePluginsIndexUpdateDownloader(),
new Extensibility.PluginsIndex.Factory(telemetryCollector),
changeNotification,
autoUpdateFactory.CreateAppUpdateDownloader()
);
AutoUpdate.IAutoUpdater autoUpdater = autoUpdateFactory.CreateAutoUpdater(pluginsManager);
Model expensibilityModel = new Model(
modelSynchronizationContext,
changeNotification,
webContentCache,
contentCache,
storageManager,
bookmarks,
logSourcesManager,
modelThreads,
tempFilesManager,
new Preprocessing.Model(
logSourcesPreprocessings,
preprocessingStepsFactory,
preprocessingManagerExtensionsRegistry
),
progressAggregator,
logProviderFactoryRegistry,
userDefinedFormatsManager,
recentlyUsedLogs,
progressAggregatorFactory,
shutdown,
webBrowserDownloader,
postprocessingModel,
pluginsManager,
traceSourceFactory,
fileSystem
);
tracer.Info("model creation completed");
return(new ModelObjects
{
GlobalSettingsAccessor = globalSettingsAccessor,
InstancesCounter = instancesCounter,
Shutdown = shutdown,
TelemetryCollector = telemetryCollector,
FirstStartDetector = firstStartDetector,
LaunchUrlParser = launchUrlParser,
ChangeNotification = changeNotification,
BookmarksFactory = bookmarksFactory,
LogSourcesManager = logSourcesManager,
ModelThreads = modelThreads,
FiltersManager = filtersManager,
Bookmarks = bookmarks,
SearchManager = searchManager,
FiltersFactory = filtersFactory,
LogSourcesPreprocessings = logSourcesPreprocessings,
UserDefinedSearches = userDefinedSearches,
SearchHistory = searchHistory,
ProgressAggregatorFactory = progressAggregatorFactory,
PreprocessingStepsFactory = preprocessingStepsFactory,
WorkspacesManager = workspacesManager,
RecentlyUsedLogs = recentlyUsedLogs,
LogProviderFactoryRegistry = logProviderFactoryRegistry,
UserDefinedFormatsManager = userDefinedFormatsManager,
PluginFormatsManager = userDefinedFormatsManager,
FormatDefinitionsRepository = formatDefinitionsRepository,
TempFilesManager = tempFilesManager,
StorageManager = storageManager,
TelemetryUploader = telemetryUploader,
ProgressAggregator = progressAggregator,
PostprocessorsManager = postprocessorsManager,
CorrelationManager = correlationManager,
ExpensibilityEntryPoint = expensibilityModel,
AnalyticsShortNames = analyticsShortNames,
SynchronizationContext = modelSynchronizationContext,
AutoUpdater = autoUpdater,
CommandLineHandler = commandLineHandler,
LogSourceNamesProvider = logSourceNamesProvider,
HeartBeatTimer = heartBeatTimer,
ThreadColorsLease = threadColorsLease,
PluginsManager = pluginsManager,
TraceSourceFactory = traceSourceFactory,
MatrixFactory = matrixFactory,
RegexFactory = regexFactory,
FieldsProcessorFactory = fieldsProcessorFactory,
FileSystem = fileSystem
});
}
