public Service1(ILogFactory _log)
{
InitializeComponent();
this.log = _log.GetLogger("task1Logger");
this.logAppointment = _log.GetLogger("task2Logger");
TestLog();
}
public static ILogger GetLogger(Type type)
{
if (_logFactory == null)
{
throw new NullReferenceException(MSG_EX_NO_FACTORY);
}
return(_logFactory.GetLogger(type));
}
public static ILog GetLogger(Type type)
{
if (_factory != null)
{
return(_factory.GetLogger(type));
}
return(Default.GetLogger(type));
}
public static void Init(ILogFactory logFactory)
{
if (logFactory == null)
{
throw new ArgumentNullException(nameof(logFactory));
}
MainLog = logFactory.GetLogger("MainLog");
Http404Log = logFactory.GetLogger("Http404Log");
}
public ReadingListService(
ITrelloFactory factory,
ILogFactory logFactory)
{
_board = factory.Board(TrelloBoardConstants.BoardId);
_logger = logFactory.GetLogger(this.GetType());
}
public BaseRedisHelper(IRedisClientManager redisClientManager, ILogFactory logFactory, TimeSpan?ttlTimeSpan)
{
_redisClientManager = redisClientManager;
Logger = logFactory.GetLogger(GetType());
_contractResolver = new DefaultContractResolver();
TtlTimeSpan = ttlTimeSpan;
}
public void BuildUp(IBuilderContext context)
{
if (context.Existing == null)
{
context.Existing = logFactory.GetLogger(this.LogType);
}
}
public ExpensesController(
IExpenseRepository expenseRepository,
ILogFactory logFactory)
{
logger = logFactory.GetLogger <ExpensesController>();
_expenseRepository = expenseRepository;
}
private async Task <IHtmlDocument> GetHtmlDocumentAsync(string url)
{
try {
_webClient.UserAgent = _boomkatConfiguration.WebClientUserAgent;
var htmlContent = await _webClient.GetAsync(url);
var htmlDocument = new HtmlDocumentImpl(new HtmlDocument());
htmlDocument.LoadHtml(htmlContent);
return(htmlDocument);
}
catch (Exception ex) {
_logFactory.GetLogger(typeof(BoomkatFeedItemService))
.ErrorFormat(HtmlWebLoadErrorMessageFormat, url, ex.Message);
throw new BoomkatServiceException(string.Format(HtmlWebLoadErrorMessageFormat, url, ex.Message));
}
}
public static ILogger GetLogger(string loggerName = null, [CallerFilePath] string callerFilePath = null)
{
if (loggerName == null)
{
loggerName = Path.GetFileNameWithoutExtension(callerFilePath);
}
return(_logFactory.GetLogger(loggerName));
}
public CachedReadingListService(
IReadingListService readingListService,
IReadingListCache readingListCache,
ILogFactory logFactory)
{
_readingListService = readingListService;
_readingListCache = readingListCache;
_logger = logFactory.GetLogger(this.GetType());
}
public CallbackModule(
IReadingListCache readingListCache,
ILogFactory logger,
ITrelloWebHookSources webHookSource)
{
_logger = logger.GetLogger(GetType());
_readingListCache = readingListCache;
_webHookSource = webHookSource;
}
public GithubBookRecordService(
IGitBookRecordCache gitBookRecordCache,
GithubClient githubFileClient,
ILogFactory logFactory)
{
_gitBookRecordCache = gitBookRecordCache;
_githubFileClient = githubFileClient;
_logger = logFactory.GetLogger(GetType());
}
public static ILogger SafeGetCurrentClassLogger(this ILogFactory factory)
{
if (factory == null)
{
return(NullLogger.Instance);
}
string name = GetCurrentClassName(2);
return(factory.GetLogger(name));
}
public RecordingService(ILogFactory loggerFactory, IRecordingRepository recordingRepository, ISoundWordsConfiguration soundWordsConfiguration, IDbConnectionFactory dbConnectionFactory, IFileSystem fileSystem, IServerEvents serverEvents, IBackgroundPool backgroundPool)
{
_logger = loggerFactory.GetLogger(GetType());
_recordingRepository = recordingRepository;
_soundWordsConfiguration = soundWordsConfiguration;
_dbConnectionFactory = dbConnectionFactory;
_fileSystem = fileSystem;
_serverEvents = serverEvents;
_backgroundPool = backgroundPool;
}
static void Test1()
{
var logger = logFactory.GetLogger();
logger.Debug("test1 debug");
logger.Info("test 1 info");
logger.Error("test1 error");
logger.Error("test1 error", new Exception("test exception"));
logger.ErrorFormat("test1 at {0}", DateTime.Now);
}
public RebuildJob(ILogFactory logFactory, ISoundWordsConfiguration soundWordsConfiguration, IDbConnectionFactory dbConnectionFactory,
IServerEvents serverEvents, IFileSystem fileSystem,
Func <string, bool, File.IFileAbstraction> fileAbstractionFactory)
{
_logger = logFactory.GetLogger(GetType());
_soundWordsConfiguration = soundWordsConfiguration;
_dbConnectionFactory = dbConnectionFactory;
_serverEvents = serverEvents;
_fileSystem = fileSystem;
_fileAbstractionFactory = fileAbstractionFactory;
}
public async Task <AlbumSearchResult> AlbumSearchAsync(string artist, string album)
{
try {
return(await _serviceClient.GetAsync <AlbumSearchResult>(_urlBuilder.BuildAlbumSearchUrl(artist, album)));
}
catch (Exception ex) {
_logFactory.GetLogger(typeof(SearchService))
.ErrorFormat(AlbumSearchErrorMessageFormat, artist, album, ex.Message);
throw new SpotifyServiceException(
string.Format(AlbumSearchErrorMessageFormat, artist, album, ex.Message), ex);
}
}
public void LogManager_InjectionTest()
{
ILogFactory factory = Mocks.CreateMock <ILogFactory>();
Expect.Call(factory.GetLogger(GetType())).Return(Mocks.DynamicMock <ILog>());
ReplayAll();
LogManager.LogFactory = factory;
ILog log = LogManager.GetLogger(GetType());
Assert.IsNotNull(log);
VerifyAll();
}
public ServiceRunner
(
ILogFactory logFactory,
IPeriodicProcessScheduler periodicProcessScheduler,
IEventPublisher <IServiceRequest> serviceEventPublisher,
[ImportMany] IEnumerable <IjTechService> services
)
{
_log = logFactory.GetLogger(this);
_periodicProcessScheduler = periodicProcessScheduler;
_serviceEventPublisher = serviceEventPublisher;
_services = services.ToList();
}
public ServiceBoot
(
ILogFactory logFactory,
IServiceInstance serviceInstance,
IEventPublisher <IServiceRequest> serviceEventPublisher
)
{
_log = logFactory.GetLogger(this);
_serviceInstance = serviceInstance;
serviceEventPublisher.GetEvent <GracefulShutdownRequest>()
.Take(1) // One is enough.
.Subscribe(OnGracefulShutdownRequest);
}
public StaticDataProvider(ILogFactory logFactory)
{
logger = logFactory.GetLogger <StaticDataProvider>();
_enumTypes = new Type[]
{
typeof(Data.Enums.Currency),
typeof(Data.Enums.TransactionType)
};
string enumsText = string.Join(", ", _enumTypes.Select(e => e.ToString()));
logger.Info($"Providing StaticData for enums - [ {enumsText} ]");
}
public TrelloApiKeyAuthenticationHandler(
IOptionsMonitor <TrelloApiKeyAuthenticationOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock,
IOptions <TrelloAuthSettings> configuredTrelloAuthSettings,
ITrelloAuthorizationWrapper trelloAuthWrapper,
ILogFactory logFactory)
: base(options, logger, encoder, clock)
{
_configuredTrelloAuthSettings = configuredTrelloAuthSettings.Value;
_trelloAuthWrapper = trelloAuthWrapper;
_logger = logFactory.GetLogger(this.GetType());
}
public BackgroundPool(ILogFactory logFactory, IApplicationLifetime lifetime, IComponentContext componentContext)
{
_logger = logFactory.GetLogger(GetType());
_lifetime = lifetime;
_componentContext = componentContext;
_lifetime.ApplicationStopped.Register(() =>
{
lock (_currentTasksLock)
{
Task.WaitAll(_currentTasks.ToArray());
}
_logger.Info("Background pool closed.");
});
}
public async Task <string> GetAsync(string url)
{
try {
using (var client = new HttpClient()) {
if (!string.IsNullOrWhiteSpace(UserAgent))
{
client.DefaultRequestHeaders.UserAgent.ParseAdd(UserAgent);
}
var response = await client.GetAsync(url);
return(await response.Content.ReadAsStringAsync());
}
}
catch (Exception ex) {
_logFactory.GetLogger(typeof(WebClient)).ErrorFormat(
WebClientErrorMessageFormat, url, ex.Message);
throw;
}
}
public static void ConfigureExceptionHandler(this IApplicationBuilder app, ILogFactory logFactory)
{
var logger = logFactory.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
app.UseExceptionHandler(appError =>
{
appError.Run(async context =>
{
context.Response.ContentType = "application/json";
var contextFeature = context.Features.Get <IExceptionHandlerFeature>();
if (contextFeature != null)
{
logger.Error($"Something went wrong: {contextFeature.Error}");
var res = new ApiResponseBase();
res.SetInternalErrorResponse(context.Response, "Internal Server Error." + contextFeature.Error.Message);
await context.Response.WriteAsync(JsonConvert.SerializeObject(res));
}
});
});
}
public async Task <T> GetAsync <T>(string url)
{
var retries = 0;
var serviceCallIsSuccessfull = false;
var responseObject = default(T);
while (!serviceCallIsSuccessfull &&
(retries == 0 || retries < _jsonServiceClientConfiguration.MaxNumberOfRetries))
{
try {
if (retries > 0)
{
var milliseconds = _jsonServiceClientConfiguration.SlowDownFactor * (retries * retries);
await Task.Delay(milliseconds);
}
var response = await _webClient.GetAsync(url);
serviceCallIsSuccessfull = true;
return(JsonConvert.DeserializeObject <T>(response));
}
catch (Exception ex) {
_logFactory.GetLogger(typeof(WebClient)).ErrorFormat(
JsonServiceClientErrorMessageFormat, url, ex.Message);
if (retries == _jsonServiceClientConfiguration.MaxNumberOfRetries - 1)
{
throw;
}
retries++;
}
}
return(responseObject);
}
public ServiceInstance
(
ILogFactory logFactory,
IConfiguration configuration,
IServiceRunner serviceRunner
)
{
try
{
_log = logFactory.GetLogger(this);
_serviceRunner = serviceRunner;
//this.ServiceName = configuration[ServiceNameKey];
InstanceStopped = new ManualResetEvent(false);
InitializeComponent();
}
catch (Exception e)
{
_log.Log(LogCatagory.Error, e, "Service Instance caught an unexpected exception on initialise.");
throw;
}
}
public void Intercept(IInvocation invocation)
{
_logger = _logFactory.GetLogger(invocation.TargetType);
if (_logger.IsDebugEnabled)
{
_logger.Debug(_invocationLogStringBuilder.BuildLogString(invocation, InvocationPhase.Start));
}
try
{
invocation.Proceed();
if (_logger.IsDebugEnabled)
{
_logger.Debug(_invocationLogStringBuilder.BuildLogString(invocation, InvocationPhase.End));
}
}
catch (Exception ex)
{
if (_logger.IsErrorEnabled)
{
_logger.Error(_invocationLogStringBuilder.BuildLogString(invocation, InvocationPhase.Error), ex);
}
throw;
}
}
public SimilarArtistsResponse GetSimilarArtists(string artist)
{
try {
var similarArtistsResponse =
_serviceClient.Get <SimilarArtistsResponse>(_urlBuilder.BuildArtistGetSimilatUrl(artist));
if (similarArtistsResponse.SimilarArtists == null)
{
similarArtistsResponse.SimilarArtists = new SimilarArtists {
Artists = new Artist[] {}
};
}
if (similarArtistsResponse.SimilarArtists.Artists == null)
{
similarArtistsResponse.SimilarArtists.Artists = new Artist[] {};
}
return(similarArtistsResponse);
}
catch (Exception ex) {
_logFactory.GetLogger(typeof(ArtistService))
.ErrorFormat(GetSimilarArtistsErrorMessageFormat, artist, ex.Message);
throw new LastfmServiceException(
string.Format(GetSimilarArtistsErrorMessageFormat, artist, ex.Message), ex);
}
}
public ScoreboardModule(IDataStorage dataStorage, ICryptation cryptation, ILogFactory logger) : base("/api/v1")
{
StaticConfiguration.DisableErrorTraces = false;
m_dataStorage = dataStorage;
m_cryptation = cryptation;
m_logger = logger.GetLogger(GetType());
Get["/ping"] = parameters =>
{
var response = (Response)"pong";
response.StatusCode = HttpStatusCode.OK;
return response;
};
Post["/addScoreBoardData"] = parameters =>
{
try
{
var scoreBoardData = this.Bind<ScoreRecord>();
int createdId = m_dataStorage.AddScoreRecordToStorage(scoreBoardData);
var response = Response.AsJson(createdId);
response.StatusCode = HttpStatusCode.Created;
return response;
}
catch (Exception e)
{
m_logger.Error(e.Message, e);
var response = (Response)e.ToString();
response.StatusCode = HttpStatusCode.BadRequest;
return response;
}
};
Get["/gameScoreBoard"] = parameters =>
{
string gameNameFromQuery = Request.Query["gameName"];
string numberOfRecords = Request.Query["count"];
int count;
if (int.TryParse(numberOfRecords, out count))
{
try
{
return Response.AsJson(m_dataStorage.GetScoresForGame(gameNameFromQuery, count));
}
catch (Exception e)
{
m_logger.Error(e.Message, e);
var response = (Response)e.ToString();
response.StatusCode = HttpStatusCode.BadRequest;
return response;
}
}
return Response.AsJson(m_dataStorage.GetAllScoresForGame(gameNameFromQuery));
};
Get["/countHigherScores"] = parameters =>
{
string gameNameFromQuery = Request.Query["gameName"];
string scoreFromQuery = Request.Query["score"];
int count;
if (int.TryParse(scoreFromQuery, out count))
{
try
{
return Response.AsJson(m_dataStorage.CountHigherScores(gameNameFromQuery, count));
}
catch (Exception e)
{
m_logger.Error(e.Message, e);
var response = (Response)e.ToString();
response.StatusCode = HttpStatusCode.BadRequest;
return response;
}
}
return Response.AsJson(m_dataStorage.GetAllScoresForGame(gameNameFromQuery));
};
Get["/playerScoreBoard"] = parameters =>
{
try
{
string playerNameFromQuery = Request.Query["playerName"];
return Response.AsJson(m_dataStorage.GetAllScoresForUsername(playerNameFromQuery));
}
catch (Exception e)
{
m_logger.Error(e.Message, e);
var response = (Response)e.ToString();
response.StatusCode = HttpStatusCode.BadRequest;
return response;
}
};
Get["/gameNames"] = parameters =>
{
try
{
return Response.AsJson(m_dataStorage.GetAllGameNames());
}
catch (Exception e)
{
m_logger.Error(e.Message, e);
var response = (Response)e.ToString();
response.StatusCode = HttpStatusCode.BadRequest;
return response;
}
};
}