public void AddProvider(ILoggerProvider provider) { lock (_sync) { _providers = _providers.Concat(new[] { provider }).ToArray(); foreach (var logger in _loggers) logger.Value.AddProvider(provider); } }
public MigrationsOperations( [NotNull] ILoggerProvider loggerProvider, [NotNull] string assemblyName, [NotNull] string startupAssemblyName, [NotNull] string projectDir, [NotNull] string rootNamespace, [CanBeNull] IServiceProvider dnxServices = null) { Check.NotNull(loggerProvider, nameof(loggerProvider)); Check.NotEmpty(assemblyName, nameof(assemblyName)); Check.NotEmpty(startupAssemblyName, nameof(startupAssemblyName)); Check.NotNull(projectDir, nameof(projectDir)); Check.NotNull(rootNamespace, nameof(rootNamespace)); var loggerFactory = new LoggerFactory(); loggerFactory.AddProvider(loggerProvider); _loggerProvider = loggerProvider; _logger = new LazyRef<ILogger>(() => loggerFactory.CreateCommandsLogger()); _projectDir = projectDir; _rootNamespace = rootNamespace; _servicesBuilder = new DesignTimeServicesBuilder(dnxServices); _contextOperations = new DbContextOperations( loggerProvider, assemblyName, startupAssemblyName, dnxServices); }
public ConfigurationOptionSettingsProvider(ILoggerProvider loggerProvider, IEc2Service ec2Service, IElasticBeanstalkServiceConfigurationProvider configurationProvider) { this.configurationProvider = configurationProvider; this.ec2Service = ec2Service; this.loggerProvider = loggerProvider; }
public IdentityManagementService(IIdentityManagementServiceConfigurationProvider configurationProvider, ILoggerProvider loggerProvider) { this.loggerProvider = loggerProvider; this.configurationProvider = configurationProvider; credentials = new BasicAWSCredentials(configurationProvider.AccessKey, configurationProvider.SecretKey); }
public CustomDiskCache(ILoggerProvider lp, string physicalCachePath, int subfolders, bool hashModifiedDate, long asyncMaxQueuedBytes) { this.lp = lp; this.physicalCachePath = physicalCachePath; this.subfolders = subfolders; this.hashModifiedDate = hashModifiedDate; this.CurrentWrites.MaxQueueBytes = asyncMaxQueuedBytes; }
internal MethodWeaver(TypeReferenceProvider typeReferenceProvider, MethodReferenceProvider methodReferenceProvider, ILoggerProvider loggerProvider, MethodDefinition methodDefinition) { _typeReferenceProvider = typeReferenceProvider; _methodReferenceProvider = methodReferenceProvider; _methodDefinition = methodDefinition; _body = methodDefinition.Body; _loggerProvider = loggerProvider; }
/// <summary> /// Adds the provider. /// </summary> /// <param name="providers">The providers.</param> public void AddProvider(ILoggerProvider[] providers) { lock (lockObject) { _providers.AddRange(providers); //When add the provider, will need to update the provider of original logger foreach (var logger in _loggers) { logger.Value.AddProvider(providers); } } }
public DatabaseTool( [CanBeNull] IServiceProvider serviceProvider, [NotNull] ILoggerProvider loggerProvider) { Check.NotNull(loggerProvider, nameof(loggerProvider)); _serviceProvider = new ServiceProvider(serviceProvider); _loggerProvider = loggerProvider; }
public QueryEngineParameterValueProvider(IQueryEngine queryEngine, IResultBuilder resultBuilder, bool required, string name, ILoggerProvider loggerProvider) { _queryEngine = queryEngine; ResultBuilder = resultBuilder; Required = required; Name = name; TimerLogger = loggerProvider.GetLogger(LogHeirarchy.Root.Timer.Value, GetType()); FlowLogger = loggerProvider.GetLogger(LogHeirarchy.Root.Flow.Value, GetType()); }
/// <summary> /// Creates and starts a thread that consumes the queue, pausing until notified when 'queue' empties. /// </summary> /// <param name="cs"></param> /// <param name="queue"></param> /// <param name="cache"></param> public CleanupWorker(ILoggerProvider lp, CleanupStrategy cs, CleanupQueue queue, CustomDiskCache cache) : base("DiskCache-CleanupWorker") { this.cs = cs; this.queue = queue; this.cache = cache; this.lp = lp; t = new Thread(main); t.IsBackground = true; t.Start(); }
public ElasticBeanstalkService(IElasticBeanstalkServiceConfigurationProvider configurationProvider, ILoggerProvider loggerProvider) { this.loggerProvider = loggerProvider; this.configurationProvider = configurationProvider; creds = new BasicAWSCredentials(configurationProvider.AccessKey, configurationProvider.SecretKey); currentCNamePrefix = $"{configurationProvider.CNamePrefix}-{configurationProvider.DeploymentEnvironmentName}"; loggerProvider.GetLogger().Debug("Current CNamePrefix: {currentCNamePrefix}", currentCNamePrefix); nextCNamePrefix = $"{configurationProvider.CNamePrefix}Next-{configurationProvider.DeploymentEnvironmentName}"; loggerProvider.GetLogger().Debug("Next CNamePrefix: {nextCNamePrefix}", nextCNamePrefix); }
public MigrationTool([NotNull] ILoggerProvider loggerProvider, [NotNull] Assembly assembly) { Check.NotNull(loggerProvider, nameof(loggerProvider)); Check.NotNull(assembly, nameof(assembly)); var loggerFactory = new LoggerFactory(); loggerFactory.AddProvider(loggerProvider); _loggerProvider = loggerProvider; _logger = new LazyRef<ILogger>(() => loggerFactory.CreateLogger<MigrationTool>()); _assembly = assembly; }
public Program(IApplicationEnvironment appEnv, ILoggerProvider logProvider) { _logger = logProvider?.CreateLogger(this.GetType().ToString()) ?? new ConsoleLogger(this.GetType().ToString(), (catgory,level) => { return true; }, true); Configuration = new ConfigurationBuilder() .SetBasePath(appEnv.ApplicationBasePath) .AddJsonFile("config.json", true) .Build(); _migrator = new Migrator(Configuration, appEnv.ApplicationName); }
public DbContextOperations( [NotNull] ILoggerProvider loggerProvider, [NotNull] string assemblyName, [NotNull] string startupAssemblyName, [CanBeNull] string environment) { Check.NotNull(loggerProvider, nameof(loggerProvider)); Check.NotEmpty(assemblyName, nameof(assemblyName)); Check.NotEmpty(startupAssemblyName, nameof(startupAssemblyName)); _loggerProvider = loggerProvider; _assemblyName = assemblyName; _startupAssemblyName = startupAssemblyName; _logger = new LazyRef<ILogger>(() => _loggerProvider.CreateCommandsLogger()); var startup = new StartupInvoker(startupAssemblyName, environment); _runtimeServices = startup.ConfigureServices(); }
internal static void SetLoggerProvider(ILoggerProvider ilp) { lock (logInstances) { currentLoggerProvider = ilp; foreach (KeyValuePair<string, ILog> aLog in logInstances) { if (ilp == null) { aLog.Value.setWrappedInstance(null); } else { aLog.Value.setWrappedInstance(currentLoggerProvider.GetLogger(aLog.Key)); } } } }
public DatabaseOperations( [NotNull] ILoggerProvider loggerProvider, [NotNull] string assemblyName, [NotNull] string startupAssemblyName, [CanBeNull] string environment, [NotNull] string projectDir, [NotNull] string rootNamespace) { Check.NotNull(loggerProvider, nameof(loggerProvider)); Check.NotEmpty(assemblyName, nameof(assemblyName)); Check.NotEmpty(startupAssemblyName, nameof(startupAssemblyName)); Check.NotNull(projectDir, nameof(projectDir)); Check.NotNull(rootNamespace, nameof(rootNamespace)); _loggerProvider = loggerProvider; _projectDir = projectDir; _rootNamespace = rootNamespace; var startup = new StartupInvoker(startupAssemblyName, environment); _servicesBuilder = new DesignTimeServicesBuilder(startup); }
public DbContextOperations([NotNull] ILoggerProvider loggerProvider, [NotNull] Assembly assembly, [NotNull] Assembly startupAssembly, [CanBeNull] string environment, [NotNull] string contentRootPath) { Check.NotNull(loggerProvider, nameof(loggerProvider)); Check.NotNull(assembly, nameof(assembly)); Check.NotNull(startupAssembly, nameof(startupAssembly)); Check.NotEmpty(contentRootPath, nameof(contentRootPath)); _loggerProvider = loggerProvider; _assembly = assembly; _startupAssembly = startupAssembly; _environment = environment; _contentRootPath = contentRootPath; _logger = new LazyRef<ILogger>(() => _loggerProvider.CreateCommandsLogger()); var startup = new StartupInvoker(_logger, startupAssembly, environment, contentRootPath); _runtimeServices = startup.ConfigureServices(); }
public CloudFrontDeployer(ElasticBeanstalkDeploymentConfigurationProvider configProvider, IElasticBeanstalkService elasticBeanstalkService, IS3Service s3Service, ISmokeTestService smokeTestService, IIdentityManagementService iamService, ICloudFrontService cloudFrontService, ISslUploaderService sslUploaderService, IConfigurationOptionSettingsProvider configurationOptionSettingsProvider, IRoute53Service route53Service, ILoggerProvider loggerProvider) { this.configurationOptionSettingsProvider = configurationOptionSettingsProvider; this.smokeTestService = smokeTestService; this.elasticBeanstalkService = elasticBeanstalkService; this.s3Service = s3Service; this.configProvider = configProvider; this.iamService = iamService; this.cloudFrontService = cloudFrontService; this.sslUploaderService = sslUploaderService; this.route53Service = route53Service; this.loggerProvider = loggerProvider; }
public CleanupManager(ILoggerProvider lp, CustomDiskCache cache, CleanupStrategy cs) { this.cache = cache; this.cs = cs; this.lp = lp; queue = new CleanupQueue(); //Called each request cache.CacheResultReturned += delegate(CustomDiskCache sender, CacheResult r) { if (r.Result == CacheQueryResult.Miss) this.AddedFile(r.RelativePath); //It was either updated or added. else this.BeLazy(); }; //Called when the filesystem changes unexpectedly. cache.Index.FileDisappeared += delegate(string relativePath, string physicalPath) { if (lp.Logger != null) lp.Logger.Warn("File disappeared from the cache unexpectedly - reindexing entire cache. File name: {0}", relativePath); //Stop everything ASAP and start a brand new cleaning run. queue.ReplaceWith(new CleanupWorkItem(CleanupWorkItem.Kind.CleanFolderRecursive, "", cache.PhysicalCachePath)); worker.MayHaveWork(); }; worker = new CleanupWorker(lp, cs,queue,cache); }
public DatabaseOperations( [NotNull] ILoggerProvider loggerProvider, [NotNull] AssemblyLoader startupAssemblyLoader, [NotNull] Assembly startupAssembly, [CanBeNull] string environment, [NotNull] string projectDir, [NotNull] string contentRootPath, [NotNull] string rootNamespace) { Check.NotNull(startupAssemblyLoader, nameof(startupAssemblyLoader)); Check.NotNull(loggerProvider, nameof(loggerProvider)); Check.NotNull(startupAssembly, nameof(startupAssembly)); Check.NotNull(projectDir, nameof(projectDir)); Check.NotEmpty(contentRootPath, nameof(contentRootPath)); Check.NotNull(rootNamespace, nameof(rootNamespace)); _loggerProvider = loggerProvider; _projectDir = projectDir; _rootNamespace = rootNamespace; var logger = new LazyRef<ILogger>(() => loggerProvider.CreateCommandsLogger()); var startup = new StartupInvoker(logger, startupAssembly, environment, contentRootPath); _servicesBuilder = new DesignTimeServicesBuilder(startupAssemblyLoader, startup); }
public static DbContextOptionsBuilder UseLoggerProvider(this DbContextOptionsBuilder builder, ILoggerProvider provider) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (provider == null) { throw new ArgumentNullException(nameof(provider)); } var extension = builder.Options.FindExtension <CoreOptionsExtension>(); var loggerFactory = extension?.LoggerFactory; if (extension.LoggerFactory != null) { loggerFactory.AddProvider(provider); } else { builder.UseLoggerFactory(new LoggerFactory(new ILoggerProvider[] { provider })); } return(builder); }
public WebConfigWriter(ILoggerProvider lp, string physicalDirPath) : this(lp,physicalDirPath, null) { }
public static void SetLoggerProvider(ILoggerProvider loggerProvider) { LogManager.SetLoggerProvider(loggerProvider); }
public CustomDiskCache(ILoggerProvider lp, string physicalCachePath, int subfolders, bool hashModifiedDate) : this(lp,physicalCachePath,subfolders,hashModifiedDate, 1024*1024*10) { }
/// <summary> /// Adds a <see cref="ILoggerProvider" /> to the logger factory used by the driver. /// <para> /// Be sure to call this method before initializing the <see cref="ICluster"/> to ensure that /// <see cref="ILoggerFactory"/> API is used as driver logging mechanism instead of /// <see cref="Trace"/>. /// </para> /// </summary> /// <param name="provider">The logger provider to add to the logger factory</param> public static void AddLoggerProvider(ILoggerProvider provider) { UseLoggerFactory = true; LoggerFactory.AddProvider(provider); }
public S3Service(IS3ConfigurationProvider s3ConfigurationProvider, ILoggerProvider loggerProvider) { this.loggerProvider = loggerProvider; this.s3ConfigurationProvider = s3ConfigurationProvider; credentials = new BasicAWSCredentials(s3ConfigurationProvider.AccessKey, s3ConfigurationProvider.SecretKey); }
public static ITestHost CreateJobHost( IOptions <DurableTaskOptions> options, string storageProvider, Type durabilityProviderFactoryType, ILoggerProvider loggerProvider, INameResolver nameResolver, IDurableHttpMessageHandlerFactory durableHttpMessageHandler, ILifeCycleNotificationHelper lifeCycleNotificationHelper, IMessageSerializerSettingsFactory serializerSettingsFactory, Action <ITelemetry> onSend, bool addDurableClientFactory, ITypeLocator typeLocator) { // Unless otherwise specified, use legacy partition management for tests as it makes the task hubs start up faster. // These tests run on a single task hub workers, so they don't test partition management anyways, and that is tested // in the DTFx repo. if (!options.Value.StorageProvider.ContainsKey(nameof(AzureStorageOptions.UseLegacyPartitionManagement))) { options.Value.StorageProvider.Add(nameof(AzureStorageOptions.UseLegacyPartitionManagement), true); } IHost host = new HostBuilder() .ConfigureLogging( loggingBuilder => { loggingBuilder.AddProvider(loggerProvider); }) .ConfigureWebJobs( webJobsBuilder => { if (addDurableClientFactory) { webJobsBuilder.AddDurableClientFactoryDurableTask(options); } else { webJobsBuilder.AddDurableTask(options, storageProvider, durabilityProviderFactoryType); } webJobsBuilder.AddAzureStorage(); }) .ConfigureServices( serviceCollection => { serviceCollection.AddSingleton(typeLocator); serviceCollection.AddSingleton(nameResolver); serviceCollection.AddSingleton(durableHttpMessageHandler); if (lifeCycleNotificationHelper != null) { serviceCollection.AddSingleton(lifeCycleNotificationHelper); } if (serializerSettingsFactory != null) { serviceCollection.AddSingleton(serializerSettingsFactory); } if (onSend != null) { serviceCollection.AddSingleton <ITelemetryActivator>(serviceProvider => { var durableTaskOptions = serviceProvider.GetService <IOptions <DurableTaskOptions> >(); var nameResolver = serviceProvider.GetService <INameResolver>(); var telemetryActivator = new TelemetryActivator(durableTaskOptions, nameResolver) { OnSend = onSend, }; return(telemetryActivator); }); } }) .Build(); return(new FunctionsV2HostWrapper(host, options, nameResolver)); }
protected override async Task <int> ExecuteEngineAsync( CommandContext commandContext, PreviewCommandSettings commandSettings, IEngineManager engineManager) { SetPipelines(commandContext, commandSettings, engineManager); ExitCode exitCode = ExitCode.Normal; ILogger logger = engineManager.Engine.Services.GetRequiredService <ILogger <Bootstrapper> >(); // Execute the engine for the first time using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource()) { if (!await engineManager.ExecuteAsync(cancellationTokenSource)) { return((int)ExitCode.ExecutionError); } } // Start the preview server Dictionary <string, string> contentTypes = commandSettings.ContentTypes?.Length > 0 ? GetContentTypes(commandSettings.ContentTypes) : new Dictionary <string, string>(); ILoggerProvider loggerProvider = engineManager.Engine.Services.GetRequiredService <ILoggerProvider>(); IDirectory outputDirectory = engineManager.Engine.FileSystem.GetOutputDirectory(); Server previewServer = null; if (outputDirectory.Exists) { previewServer = await StartPreviewServerAsync( outputDirectory.Path, commandSettings.Port, commandSettings.ForceExt, commandSettings.VirtualDirectory, !commandSettings.NoReload, contentTypes, loggerProvider, logger); } // Start the watchers ActionFileSystemWatcher inputFolderWatcher = null; if (!commandSettings.NoWatch) { logger.LogInformation("Watching paths(s) {0}", string.Join(", ", engineManager.Engine.FileSystem.InputPaths)); inputFolderWatcher = new ActionFileSystemWatcher( outputDirectory.Path, engineManager.Engine.FileSystem.GetInputDirectories().Select(x => x.Path), true, "*.*", path => { _changedFiles.Enqueue(path); _messageEvent.Set(); }); } // Start the message pump CommandUtilities.WaitForControlC( () => { _exit.Set(); _messageEvent.Set(); }, logger); // Wait for activity while (true) { _messageEvent.WaitOne(); // Blocks the current thread until a signal if (_exit) { break; } // Execute if files have changed HashSet <string> changedFiles = new HashSet <string>(); while (_changedFiles.TryDequeue(out string changedFile)) { if (changedFiles.Add(changedFile)) { logger.LogDebug($"{changedFile} has changed"); } } if (changedFiles.Count > 0) { logger.LogInformation($"{changedFiles.Count} files have changed, re-executing"); // Reset caches when an error occurs during the previous preview string existingResetCacheSetting = null; bool setResetCacheSetting = false; if (exitCode == ExitCode.ExecutionError) { existingResetCacheSetting = engineManager.Engine.Settings.GetString(Keys.ResetCache); setResetCacheSetting = true; ConfigurationSettings[Keys.ResetCache] = "true"; } // If there was an execution error due to reload, keep previewing but clear the cache using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource()) { exitCode = await engineManager.ExecuteAsync(cancellationTokenSource) ? ExitCode.Normal : ExitCode.ExecutionError; } // Reset the reset cache setting after removing it if (setResetCacheSetting) { if (existingResetCacheSetting == null) { ConfigurationSettings.Remove(Keys.ResetCache); } { ConfigurationSettings[Keys.ResetCache] = existingResetCacheSetting; } } if (previewServer == null) { if (outputDirectory.Exists) { previewServer = await StartPreviewServerAsync( outputDirectory.Path, commandSettings.Port, commandSettings.ForceExt, commandSettings.VirtualDirectory, !commandSettings.NoReload, contentTypes, loggerProvider, logger); } } else { await previewServer.TriggerReloadAsync(); } } // Check one more time for exit if (_exit) { break; } logger.LogInformation("Hit Ctrl-C to exit"); _messageEvent.Reset(); } // Shutdown logger.LogInformation("Shutting down"); inputFolderWatcher?.Dispose(); previewServer?.Dispose(); return((int)exitCode); }
public void AddProvider(ILoggerProvider provider) { var logger = provider.CreateLogger(_name); _loggers = _loggers.Concat(new[] {logger}).ToArray(); }
/// <summary> /// Initializes a new instance of the <see cref="LinqRepositoryContextBase"/> class. /// </summary> protected LinqRepositoryContextBase() { Conventions = RepositoryConventions.Default <LinqRepositoryContextBase>(); _loggerProvider = NullLoggerProvider.Instance; }
public WebConfigWriter(ILoggerProvider lp, string physicalDirPath, string alternateWebConfigContents) { this.physicalDirPath = physicalDirPath; this.lp = lp; if (alternateWebConfigContents != null) this.webConfigContents = alternateWebConfigContents; }
public static ILogger CreateCommandsLogger(this ILoggerProvider loggerProvider) => loggerProvider.CreateLogger(CommandsLoggerName);
public MqttNetLogger(ILoggerProvider loggerProvider) { _loggerProvider = loggerProvider; }
public MemoryConnectionPool(ILoggerProvider loggerProvider) { logger = loggerProvider.CreateLogger("MemoryConnectionPool"); }
public void AddProvider(ILoggerProvider provider) { }
public bool TryAddProvider(ILoggerProvider provider) { return(_providers.TryAdd(provider.GetType().FullName, provider)); }
public ShaderLoader(ILoggerProvider loggerProvider) { _logger = loggerProvider.CreateLogger <ShaderLoader>(); }
public void AddProvider(ILoggerProvider provider) { throw new NotImplementedException(); }
/// <summary> /// Does nothing. Used for testing purposes. /// </summary> /// <param name="provider">Not used provider parameter. Used for testing with ILogger service.</param> public void AddProvider(ILoggerProvider provider) { // intentionally does nothing }
public MqttNetChildLogger(string source, ILoggerProvider loggerProvider) { _source = source ?? string.Empty; _logger = loggerProvider.CreateLogger(source); _loggerProvider = loggerProvider; }
public void AddProvider(ILoggerProvider provider) { System.Configuration.ConfigurationManager.GetSection("system.xml/xmlReader"); }
/// <summary> /// Adds an <see cref="T:Microsoft.Extensions.Logging.ILoggerProvider" /> to the logging system. /// </summary> /// <param name="provider">The <see cref="T:Microsoft.Extensions.Logging.ILoggerProvider" />.</param> public void AddProvider(ILoggerProvider provider) { SelfLog.WriteLine("Ignoring added logger provider {0}", provider); }
internal void AddProvider(ILoggerProvider provider) { var logger = provider.Create(_name); _loggers = _loggers.Concat(new[] { logger }).ToArray(); }
public GetScheduleForStore(IMessages messages, IHttpRequestConverter httpRequestConverter, ILoggerProvider log) { _messages = messages; _httpRequestConverter = httpRequestConverter; _log = log.CreateLogger(nameof(GetScheduleForStore)); }