public Program()
{
// a DI based application would get ILoggerFactory injected instead
var factory = new LoggerFactory();
// getting the logger immediately using the class's name is conventional
_logger = factory.CreateLogger(typeof(Program).FullName);
// providers may be added to an ILoggerFactory at any time, existing ILoggers are updated
#if !DNXCORE50
factory.AddNLog(new global::NLog.LogFactory());
#endif
factory.AddConsole();
factory.AddConsole((category, logLevel) => logLevel >= LogLevel.Critical && category.Equals(typeof(Program).FullName));
}
public static ServiceProvider CreateTestServices(
IServiceProvider applicationServices,
Project project,
ReportingChannel channel)
{
var services = new ServiceProvider(applicationServices);
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new TestHostLoggerProvider(channel));
services.Add(typeof(ILoggerFactory), loggerFactory);
var libraryExporter = applicationServices.GetRequiredService<ILibraryExporter>();
var export = libraryExporter.GetExport(project.Name);
var projectReference = export.MetadataReferences
.OfType<IMetadataProjectReference>()
.Where(r => r.Name == project.Name)
.FirstOrDefault();
services.Add(
typeof(ISourceInformationProvider),
new SourceInformationProvider(projectReference, loggerFactory.CreateLogger<SourceInformationProvider>()));
services.Add(typeof(ITestDiscoverySink), new TestDiscoverySink(channel));
services.Add(typeof(ITestExecutionSink), new TestExecutionSink(channel));
return services;
}
private static async Task Run(string[] args)
{
try
{
// This wont work...
// See https://github.com/aspnet/Configuration/issues/214
//var config = new ConfigurationBuilder();
//config.AddJsonFile("wiki.json");
var jsonConfig = new JsonConfigurationSource("wiki.json");
var config = new ConfigurationBuilder(jsonConfig);
var builder = new ContainerBuilder();
var module = new ConfigurationModule(config.Build());
builder.RegisterModule(module);
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(LogLevel.Information);
builder.RegisterInstance(loggerFactory).As<ILoggerFactory>().SingleInstance();
builder.RegisterType<GetDescriptionAction>().AsImplementedInterfaces().InstancePerDependency();
builder.RegisterType<AddValueToAlternativeKeysAction>().AsImplementedInterfaces().InstancePerDependency();
builder.Register(ctx => new CompositeDictEntryAction(ctx.Resolve<IEnumerable<IDictEntryAction>>()))
.Keyed<IDictEntryAction>(DictEntryActionKey);
builder.Register(
ctx =>
new Wiki.Wiki(ctx.Resolve<HttpClient>(),
ctx.ResolveOptionalKeyed<IDictEntryAction>(DictEntryActionKey),
ctx.Resolve<ILoggerFactory>()))
.AsImplementedInterfaces()
.InstancePerDependency();
builder.RegisterInstance(new DictConfig
{
FilePath = Path.Combine("..", "..", "resources", "kindle_dict.html"),
OpfFilePath = Path.Combine("..", "..", "resources"),
TemplateFilePath = Path.Combine("..", "..", "resources", "knidle_dict_template.html"),
EntryTemplateFilePath = Path.Combine("..", "..", "resources", "knidle_dict_entry_template.html"),
OpfTemplateFilePath = Path.Combine("..", "..", "resources", "kindle_dict_template.opf"),
}).SingleInstance();
builder.RegisterType<Dict>().AsImplementedInterfaces().SingleInstance();
var logger = loggerFactory.CreateLogger(typeof (Program).FullName);
var container = builder.Build();
var wiki = container.Resolve<IWiki>();
logger.LogInformation("Getting wiki description...");
var wikiDesc = await wiki.GetDescriptionAsync().ConfigureAwait(false);
logger.LogInformation("Getting entries...");
var entries = await wiki.GetEntriesAsync().ConfigureAwait(false);
var dict = container.Resolve<IDict>();
logger.LogInformation("Saving dictionary...");
await dict.SaveAsync(wikiDesc, entries).ConfigureAwait(false);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
}
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 DatabaseTool(
[CanBeNull] IServiceProvider serviceProvider,
[NotNull] ILoggerProvider loggerProvider)
{
Check.NotNull(loggerProvider, nameof(loggerProvider));
_serviceProvider = new ServiceProvider(serviceProvider);
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
_logger = new LazyRef<ILogger>(() => loggerFactory.CreateLogger<DatabaseTool>());
_serviceProvider.AddService(typeof(ILogger), _logger.Value);
_serviceProvider.AddService(typeof(CSharpCodeGeneratorHelper), new CSharpCodeGeneratorHelper());
_serviceProvider.AddService(typeof(ModelUtilities), new ModelUtilities());
}
// This function will get triggered/executed when a new message is written
// on an Azure Queue called queue.
public async static Task NewImagesTrigger([QueueTrigger(QueueNames.NewImages)]CloudQueueMessage message, CancellationToken cancellationToken)
{
var connectionFactory = new StorageConnectionFactory(CloudConfigurationManager.GetSetting("storageAccountConnection"));
var factory = new LoggerFactory();
factory.AddConsole();
factory.AddEventLog();
var logger = factory.CreateLogger("ToprakWebjobs");
var imageManager = new ImageManagerService(connectionFactory, logger);
await imageManager.AddToCirculation(true, cancellationToken);
}
public void Execute(string[] args)
{
var options = new Options();
Parser.Default.ParseArguments(args, options);
var factory = new LoggerFactory();
factory.AddConsole();
var logger = factory.CreateLogger("category-1");
int number = options.Number;
for (int i = 0; i < number; i++)
logger.LogInformation("message " + i);
}
public async static Task ProcessedImagesTrigger([QueueTrigger(QueueNames.Seen)]CloudQueueMessage message, CancellationToken cancellationToken)
{
var connectionFactory = new StorageConnectionFactory(CloudConfigurationManager.GetSetting("storageAccountConnection"));
var factory = new LoggerFactory();
factory.AddConsole();
factory.AddEventLog();
var logger = factory.CreateLogger("ToprakWebjobs");
var imageRepository = new ImageRepository(connectionFactory, logger);
var queueRepository = new QueueRepository(connectionFactory, logger);
IResultsRepository resultsRepository = new ResultsRepository(CloudConfigurationManager.GetSetting("Database"), logger);
var envelope = TutanakDataEnvelope.GorulmusTutanakMesajiFactory(message.AsString);
envelope.TutanakData.Image = (new Uri(envelope.TutanakData.Image)).Segments[2];
await resultsRepository.RecordResult(envelope);
var imageSeen = envelope.TutanakData;
var results = (await resultsRepository.GetTutanakResultsAsync(imageSeen.Image)).ToList();
var compareProperties =
typeof(GorulmusTutanakMesaji).GetProperties()
.Where(p => p.GetCustomAttributes(false).All(a => a.GetType() != typeof(NoCompareAttribute)))
.OrderBy(p => p.Name)
.Select(p => p.Name);
var resultHashGroups =
results.Select(
r =>
compareProperties.Select(p => r.GetType().GetProperty(p).GetValue(r)).Aggregate((i, j) => $"{i},{j}"))
.GroupBy(h => h)
.Select(g => g.Count())
.OrderByDescending(c => c).ToList();
var sameReadLimit = Convert.ToInt32(CloudConfigurationManager.GetSetting("SameReadLimit"));
if (resultHashGroups.Any() && resultHashGroups.Max() >= sameReadLimit)
{
await imageRepository.TransferToProcessed(imageSeen.Image, cancellationToken);
await resultsRepository.RecordReadSuccessResult(envelope);
} else
{
await
queueRepository.AddMessageAsync(
QueueNames.ToBeProcessed,
new CloudQueueMessage(imageRepository.GetUnprocessedUri(imageSeen.Image).AbsoluteUri),
cancellationToken);
}
}
// Please set the following connection strings in app.config for this WebJob to run:
// AzureWebJobsDashboard and AzureWebJobsStorage
public static void Main()
{
var connectionFactory = new StorageConnectionFactory(CloudConfigurationManager.GetSetting("storageAccountConnection"));
var factory = new LoggerFactory();
factory.AddConsole();
factory.AddEventLog();
var logger = factory.CreateLogger("ToprakWebjobs");
AppDomain.CurrentDomain.UnhandledException +=
(sender, args) => { logger.LogCritical(args.ExceptionObject.ToString()); };
var host = new JobHost();
// The following code ensures that the WebJob will be running continuously
host.RunAndBlock();
}
public DatabaseTool(
[CanBeNull] IServiceProvider serviceProvider,
[NotNull] ILoggerProvider loggerProvider)
{
Check.NotNull(loggerProvider, nameof(loggerProvider));
_serviceProvider = new ServiceProvider(serviceProvider);
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
_logger = new LazyRef<ILogger>(() => loggerFactory.CreateLogger<DatabaseTool>());
_serviceProvider.AddService(typeof(ILogger), _logger.Value);
_serviceProvider.AddService(typeof(IFileService), new FileSystemFileService());
_serviceProvider.AddService(typeof(CSharpCodeGeneratorHelper), new CSharpCodeGeneratorHelper());
_serviceProvider.AddService(typeof(ModelUtilities), new ModelUtilities());
var metadataReferencesProvider = new MetadataReferencesProvider(_serviceProvider);
_serviceProvider.AddService(typeof(MetadataReferencesProvider), metadataReferencesProvider);
var compilationService = new RoslynCompilationService();
_serviceProvider.AddService(typeof(ITemplating), new RazorTemplating(compilationService, metadataReferencesProvider));
}
public void IsEnabled_IgnoresExceptionInIntermediateLoggers()
{
// Arrange
var store = new List<string>();
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new CustomLoggerProvider("provider1", ThrowExceptionAt.None, store));
loggerFactory.AddProvider(new CustomLoggerProvider("provider2", ThrowExceptionAt.IsEnabled, store));
loggerFactory.AddProvider(new CustomLoggerProvider("provider3", ThrowExceptionAt.None, store));
var logger = loggerFactory.CreateLogger("Test");
// Act
var aggregateException = Assert.Throws<AggregateException>(() => logger.LogInformation("Hello!"));
// Assert
Assert.Equal(new[] { "provider1.Test-Hello!", "provider3.Test-Hello!" }, store);
Assert.NotNull(aggregateException);
Assert.Equal("An error occurred while writing to logger(s).", aggregateException.Message);
Assert.Equal(1, aggregateException.InnerExceptions.Count);
var exception = aggregateException.InnerExceptions[0];
Assert.Equal("provider2.Test-Error occurred while checking if logger is enabled.", exception.Message);
}
public void BeginScope_IgnoresExceptionInIntermediateLoggersAndThrowsAggregateException()
{
// Arrange
var store = new List<string>();
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new CustomLoggerProvider("provider1", ThrowExceptionAt.None, store));
loggerFactory.AddProvider(new CustomLoggerProvider("provider2", ThrowExceptionAt.BeginScope, store));
loggerFactory.AddProvider(new CustomLoggerProvider("provider3", ThrowExceptionAt.None, store));
var logger = loggerFactory.CreateLogger("Test");
// Act
var aggregateException = Assert.Throws<AggregateException>(() => logger.BeginScope("Scope1"));
// Assert
Assert.Equal(new[] { "provider1.Test-Scope1", "provider3.Test-Scope1" }, store);
Assert.NotNull(aggregateException);
Assert.Equal("An error occurred while writing to logger(s).", aggregateException.Message);
Assert.Equal(1, aggregateException.InnerExceptions.Count);
var exception = aggregateException.InnerExceptions[0];
Assert.Equal("provider2.Test-Error occurred while creating scope.", exception.Message);
}
public void Log_AggregatesExceptionsFromMultipleLoggers()
{
// Arrange
var store = new List<string>();
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new CustomLoggerProvider("provider1", ThrowExceptionAt.Log, store));
loggerFactory.AddProvider(new CustomLoggerProvider("provider2", ThrowExceptionAt.Log, store));
var logger = loggerFactory.CreateLogger("Test");
// Act
var aggregateException = Assert.Throws<AggregateException>(() => logger.LogInformation("Hello!"));
// Assert
Assert.Empty(store);
Assert.NotNull(aggregateException);
Assert.Equal("An error occurred while writing to logger(s).", aggregateException.Message);
var exceptions = aggregateException.InnerExceptions;
Assert.Equal(2, exceptions.Count);
Assert.Equal("provider1.Test-Error occurred while logging data.", exceptions[0].Message);
Assert.Equal("provider2.Test-Error occurred while logging data.", exceptions[1].Message);
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(
c =>
{
var factory = new LoggerFactory();
factory.AddEventLog();
return factory.CreateLogger("ToprakWeb");
}).As<ILogger>().InstancePerLifetimeScope();
var connectionString = this.config["Data:ImageRepository:ConnectionString"];
var databaseConnectionString = this.config["Data:Database:ConnectionString"];
builder.Register(
c =>
connectionString == "Dev"
? new StorageConnectionFactory()
: new StorageConnectionFactory(connectionString))
.As<IStorageConnectionFactory>()
.InstancePerLifetimeScope();
builder.Register(c => new QueueRepository(c.Resolve<IStorageConnectionFactory>(), c.Resolve<ILogger>()))
.As<IQueueRepository>()
.InstancePerLifetimeScope();
builder.Register(c => new ImageRepository(c.Resolve<IStorageConnectionFactory>(), c.Resolve<ILogger>()))
.As<IImageRepository>()
.InstancePerLifetimeScope();
builder.Register(c => new ImageManagerService(c.Resolve<IQueueRepository>(), c.Resolve<IImageRepository>(), c.Resolve<ILogger>()))
.As<IImageManagerService>()
.InstancePerLifetimeScope();
builder.Register(c => new ResultsRepository.ResultsRepository(databaseConnectionString, c.Resolve<ILogger>()))
.As<IResultsRepository>()
.InstancePerLifetimeScope();
}
public Program()
{
// a DI based application would get ILoggerFactory injected instead
var factory = new LoggerFactory();
// getting the logger immediately using the class's name is conventional
_logger = factory.CreateLogger(typeof(Program).FullName);
// providers may be added to an ILoggerFactory at any time, existing ILoggers are updated
#if !DNXCORE50
factory.AddNLog(new global::NLog.LogFactory());
factory.AddSerilog(new Serilog.LoggerConfiguration()
.Enrich.WithMachineName()
.Enrich.WithProcessId()
.Enrich.WithThreadId()
.MinimumLevel.Debug()
.WriteTo.RollingFile("file-{Date}.txt", outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} {Level}:{EventId} [{SourceContext}] {Message}{NewLine}{Exception}")
.WriteTo.Sink(new RollingFileSink("file-{Date}.json", new JsonFormatter(), null, null))
.WriteTo.Sink(new FileSink("dump.txt", new RawFormatter(), null)));
#endif
factory.AddConsole();
factory.AddConsole((category, logLevel) => logLevel >= LogLevel.Critical && category.Equals(typeof(Program).FullName));
}
public Program()
{
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole();
_logger = loggerFactory.CreateLogger<Program>();
}
private ServiceCollection SetupInitialServices()
{
var serviceCollection = new ServiceCollection();
#if DNX451 || DNXCORE50
var manifest = _serviceProvider.GetRequiredService<IServiceManifest>();
if (manifest != null)
{
foreach (var service in manifest.Services)
{
serviceCollection.AddTransient(
service, sp => _serviceProvider.GetService(service));
}
}
#endif
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(_loggerProvider);
var logger = loggerFactory.CreateLogger<DatabaseTool>();
serviceCollection.AddScoped(typeof(ILogger), sp => logger);
serviceCollection.AddScoped<IFileService, FileSystemFileService>();
return serviceCollection;
}
private CommandBuilder setupCommandBuilder(DbContext context)
{
var source = new EntityMaterializerSource(new MemberMapper(new FieldMatcher()));
var loggerFactory = new LoggerFactory();
var selectExpression = new SelectExpression();
var queryCompilationContext = new RelationalQueryCompilationContext(
context.Model,
loggerFactory.CreateLogger("new"),
new LinqOperatorProvider(),
new RelationalResultOperatorHandler(),
source,
new EntityKeyFactorySource(new BoxedValueReaderSource()),
new AsyncQueryMethodProvider(),
new CompositeMethodCallTranslator());
return new CommandBuilder(selectExpression, queryCompilationContext);
}
public SmokeTests()
{
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole();
_logger = loggerFactory.CreateLogger<SmokeTests>();
}
