public async Task AddIncommingAsync <TSupplierType>(string incomingPrefix, TSupplierType supplierType, CancellationToken cancellationToken = default) { try { incomingPrefix.NotNullOrWhiteSpace(nameof(incomingPrefix)); supplierType.NotNull(nameof(supplierType)); var strSupplierType = supplierType.ConvertTo <string>(); Logger.SetProperty(LogConstants.SupplierType, strSupplierType); var cacheSetting = await CacheSettingService.GetFromCacheBySupplierTypeAsync(strSupplierType, cancellationToken).ConfigureAwait(false); var key = incomingPrefix + "-" + Guid.NewGuid().ToString("N"); await CacheManager.SetAsync(key, string.Empty, cacheSetting.RpmDurationMinutes, cancellationToken).ConfigureAwait(false); ////3 times to try //if (await TrySet().ConfigureAwait(false) == false) // if (await TrySet().ConfigureAwait(false) == false) // if (await TrySet().ConfigureAwait(false) == false) // throw new Exception($"Faild to set cache {nameof(AddSearchHistoryAsync)}"); //Task<bool> TrySet() => CacheManager.TrySetAsync(key, string.Empty, cacheSetting.RpmDurationMinutes, cancellationToken); } catch (Exception ex) when(Logger.LogErrorIfNotBefore(ex, "Exception ocurred in {MethodName}", nameof(AddIncommingAsync))) { throw; } }
public LogOperation(ILogger logger, string value) { Logger = logger; PreviousValue = Logger.GetProperty(LogContext.PropertyKey.Operation); // set the new key/value if (PreviousValue.HasValue()) { Logger.SetProperty(LogContext.PropertyKey.Operation, PreviousValue + "." + value); } else { Logger.SetProperty(LogContext.PropertyKey.Operation, value); } }
/// <summary> /// Log error if was not logged before /// </summary> /// <param name="logger">logger</param> /// <param name="exception">Exception related to the event.</param> /// <param name="messageTemplate">Message template describing the event.</param> /// <param name="propertyValues">Objects positionally formatted into the messageTemplate template.</param> /// <returns>Return false always to not catch exception in when condation</returns> public static bool LogErrorIfNotBefore(this ILogger logger, Exception exception, string messageTemplate, params object[] propertyValues) { logger.NotNull(nameof(logger)); exception.NotNull(nameof(exception)); messageTemplate.NotNull(nameof(messageTemplate)); if (LogConstants.LogErrorEnabled && !exception.IsLoggedBefore()) { logger.SetProperty(LogConstants.Exception, exception); logger.SetProperty(LogConstants.Level, LogLevel.Error); logger.Log(LogLevel.Error, exception, messageTemplate, propertyValues, new[] { new LogProperty(LogConstants.LogError, null) }); exception.MarkAsLogged(); } return(false); }
public async Task <TCacheSetting> GetFromCacheBySupplierTypeAsync <TSupplierType>(TSupplierType supplierType, CancellationToken cancellationToken = default) { try { supplierType.NotNull(nameof(supplierType)); var strSupplierType = supplierType.ConvertTo <string>(); var cacheKey = string.Format(CacheKeySupplierType, strSupplierType); var setting = await CacheManager.GetAsync(cacheKey, async() => { using (await AsyncLock.LockAsync()) { var cacheSetting = await Store.TableNoTracking.SingleOrDefaultAsync(p => p.SupplierType == strSupplierType, cancellationToken); if (cacheSetting == null) { cacheSetting = (await Store.TableNoTracking.SingleAsync(p => p.SupplierType == null, cancellationToken)).ShallowCopy <TCacheSetting>(); cacheSetting.SupplierType = strSupplierType; } return(cacheSetting); } }, 1440, cancellationToken).ConfigureAwait(false); Logger.SetProperty(LogConstants.CacheSetting, setting, true); return(setting); } catch (Exception ex) when(Logger.LogErrorIfNotBefore(ex, "Exception ocurred in {MethodName}", nameof(GetFromCacheBySupplierTypeAsync))) { throw; } }
/// <summary> /// Clear log context. /// </summary> internal static void Clear(ILogger logger) { foreach (var field in PropertyKey.Fields) { var key = field.GetValue(DummyLogContext) as string; logger.SetProperty(key, null); } }
/// <summary> /// Set all log context values from this LogContext object to logger. /// </summary> internal void Set(ILogger logger) { if (Properties == null) { return; } foreach (var propertyKeyField in PropertyKey.Fields) { var propertyKey = propertyKeyField.GetValue(DummyLogContext) as string; if (propertyKey != null && Properties.ContainsKey(propertyKey)) { var propertyValue = Properties[propertyKey]; logger.SetProperty(propertyKey, propertyValue); } } }
private LogProps(ILogger logger, string propertyName, object propertyValue) { this.logger = logger; this.propertyName = propertyName; logger.SetProperty(propertyName, propertyValue); }
public async Task AddIncommingAsync <TSupplierType>(string incomingPrefix, TSupplierType supplierType, CancellationToken cancellationToken = default) { try { incomingPrefix.NotNullOrWhiteSpace(nameof(incomingPrefix)); supplierType.NotNull(nameof(supplierType)); var strSupplierType = supplierType.ConvertTo <string>(); var hashCode = incomingPrefix.GetInvariantHashCode(); Logger.SetProperty(LogConstants.IncomingRequestHashCode, hashCode); Logger.SetProperty(LogConstants.SupplierType, strSupplierType); var incomingRequest = new IncomingRequest { CreatedAt = SystemClock.DateTimeNow, HashCode = hashCode }; using (await AsyncLock.LockAsync()) await IncomingRequestStore.AddAsync(incomingRequest, cancellationToken); } catch (Exception ex) when(Logger.LogErrorIfNotBefore(ex, "Exception ocurred in {MethodName}", nameof(AddIncommingAsync))) { throw; } }
/// <summary> /// Add a property to the log scope if not already present, otherwise, update its value. /// </summary> /// <param name="logger">logger</param> /// <param name="propertyName">The name of the property.</param> /// <param name="propertyValue">The value of the property.</param> /// <param name="destructureObjects"> /// Determines whether it must be destruct. /// If true, and the value is a non-primitive, non-array type, then the value will be converted to a structure; otherwise, unknown types will be converted to scalars, which are generally stored as strings. /// </param> public static void SetProperty(this ILogger logger, string propertyName, object propertyValue, bool destructureObjects = false) { logger.NotNull(nameof(logger)); logger.SetProperty(new LogProperty(propertyName, propertyValue, destructureObjects)); }