public void UpdateLastError(string key, string operationId)
{
// NO DISTRIBUTEC CACHE
if (Cache is null)
{
return;
}
// NO CIRCUIT-BREAKER DURATION
if (_breakDurationTicks == 0)
{
return;
}
Interlocked.Exchange(ref _gatewayTicks, DateTimeOffset.UtcNow.Ticks + _breakDurationTicks);
// DETECT CIRCUIT STATE CHANGE
var oldCircuitState = Interlocked.Exchange(ref _circuitState, CircuitStateOpen);
if (oldCircuitState == CircuitStateClosed)
{
if (_logger?.IsEnabled(LogLevel.Warning) ?? false)
{
_logger.LogWarning("FUSION (K={CacheKey} OP={CacheOperationId}): distributed cache temporarily de-activated for {BreakDuration}", key, operationId, _breakDuration);
}
}
}
private void MaybeLogWarningsAndErrors(EmitResult result)
{
var warnings = result.Diagnostics.Where(diagnostic =>
!diagnostic.IsSuppressed && !diagnostic.IsWarningAsError &&
diagnostic.Severity == DiagnosticSeverity.Warning);
foreach (var warning in warnings)
{
if (_logger?.IsEnabled(LogLevel.Warning) == true)
{
_logger?.LogWarning(JsonConvert.SerializeObject(warning));
}
}
var errors = result.Diagnostics.Where(diagnostic =>
!diagnostic.IsSuppressed && diagnostic.IsWarningAsError ||
diagnostic.Severity == DiagnosticSeverity.Error);
foreach (var error in errors)
{
if (_logger?.IsEnabled(LogLevel.Error) == true)
{
_logger?.LogError(JsonConvert.SerializeObject(error));
}
}
}
/// <summary>
/// Creates a new <see cref="DataFilter"/> object using the specified exception filter and compression filter settings.
/// </summary>
/// <param name="name">The name for the filter.</param>
/// <param name="exceptionSettings">The exception filter settings. If <see langword="null"/>, a default (disabled) exception filter will be assigned to the buffer.</param>
/// <param name="compressionSettings">The compression filter settings. If <see langword="null"/>, a default (disabled) compression filter will be assigned to the buffer.</param>
/// <param name="loggerFactory">The <see cref="ILoggerFactory"/> to use for logging.</param>
public DataFilter(string name, ExceptionFilterState exceptionSettings, CompressionFilterState compressionSettings, ILoggerFactory loggerFactory)
{
Log = loggerFactory?.CreateLogger <DataFilter>();
CanLogDebug = Log?.IsEnabled(LogLevel.Debug) ?? false;
CanLogTraceLog = Log?.IsEnabled(LogLevel.Trace) ?? false;
Name = name;
ExceptionFilter = exceptionSettings ?? throw new ArgumentNullException(nameof(exceptionSettings));
CompressionFilter = compressionSettings ?? throw new ArgumentNullException(nameof(compressionSettings));
_exceptionMonitor = new ExceptionMonitor(this);
_compressionMonitor = new CompressionMonitor(this);
IsEnabled = true;
}
/// <summary>
/// Creates a new <see cref="ApiClient"/> object with the specified base URL, credentials, and proxy settings.
/// </summary>
/// <param name="baseUrl">The base URL of the Aika API to query (e.g. <c>https://aika.myorg.com/aika</c>).</param>
/// <param name="credentials">The credentials to use when querying the Aika API.</param>
/// <param name="proxy">The proxy settings to use.</param>
/// <param name="loggerFactory">The logger factory for the API client. Can be <see langword="null"/>.</param>
/// <exception cref="ArgumentNullException"><paramref name="baseUrl"/> is <see langword="null"/>.</exception>
/// <exception cref="UriFormatException"><paramref name="baseUrl"/> is not a valid absolute URL.</exception>
public ApiClient(string baseUrl, ICredentials credentials, IWebProxy proxy, ILoggerFactory loggerFactory) : this(loggerFactory) {
if (baseUrl == null)
{
throw new ArgumentNullException(nameof(baseUrl));
}
if (!baseUrl.EndsWith("/"))
{
baseUrl = baseUrl + "/";
}
var uri = new Uri(baseUrl, UriKind.Absolute);
MessageHandler = CreateHttpMessageHandler(uri, credentials, proxy);
MessageHandler.BeforeSend += (request, ct) => {
if (Authorization != null && request.Headers.Authorization == null)
{
request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue(Authorization.Scheme, Authorization.Parameter);
}
if (_logger?.IsEnabled(LogLevel.Trace) ?? false)
{
_logger.LogTrace($"{request.Method.ToString().ToUpperInvariant()} {request.RequestUri}");
}
return(Task.CompletedTask);
};
MessageHandler.AfterResponse += (response, duration, ct) => {
if (_logger?.IsEnabled(LogLevel.Trace) ?? false)
{
string formattedDuration;
if (duration < TimeSpan.FromSeconds(1))
{
formattedDuration = $"{Math.Ceiling(duration.TotalMilliseconds)} ms";
}
else
{
formattedDuration = $"{duration.TotalSeconds:0.00} s";
}
_logger.LogTrace($"{response.RequestMessage.Method.ToString().ToUpperInvariant()} {response.RequestMessage.RequestUri} {(int) response.StatusCode}/{response.ReasonPhrase ?? response.StatusCode.ToString()} {formattedDuration}");
}
return(Task.CompletedTask);
};
HttpClient = new HttpClient(MessageHandler, false)
{
BaseAddress = uri
};
}
/// <summary>
/// Log a stack trace at the point of caller if verbose logging is enabled.
/// </summary>
/// <param name="logger">The serilog logger.</param>
/// <param name="skipFrames">Number of stack frames to ignore. This is usuful if wanting to ignore a part of the stack frame because the caller is not the important part of the stack frame.</param>
public static void StackTrace(this ILogger logger, ushort skipFrames = 0)
{
if (logger?.IsEnabled(Events.LogEventLevel.Verbose) != true)
{
return;
}
System.Diagnostics.StackTrace trace = new(true);
var indent = "";
foreach (var frame in trace.GetFrames().Reverse().Skip(1 + skipFrames))
{
var filename = frame.GetFileName()?.Split('\\').Last();
if (filename is null)
{
continue;
}
logger.Verbose(
$"{indent}[{{Line}}] {{Method}} in {{FileName}}",
frame.GetFileLineNumber(),
frame.GetMethod(),
filename);
indent += " ";
}
}
private List <NRSpans.Span> FilterSpans(List <NRSpans.Span> spans, List <string> spanIdsToFilter)
{
if (spanIdsToFilter.Count == 0)
{
return(spans);
}
var newSpansToFilter = spans.Where(x => spanIdsToFilter.Contains(x.ParentId)).ToArray();
if (newSpansToFilter.Length == 0)
{
return(spans);
}
if (_logger?.IsEnabled(LogLevel.Debug) == true)
{
foreach (var spanToFilter in newSpansToFilter)
{
_logger?.LogDebug(null, $"The following span was filtered because it is a descendant of a span that describes communication with a New Relic endpoint: Trace={spanToFilter.TraceId}, Span={spanToFilter.Id}, ParentSpan={spanToFilter.ParentId ?? "<NULL>"}");
}
}
var newSpanIdsToFilter = newSpansToFilter.Select(x => x.Id).ToArray();
spanIdsToFilter = spanIdsToFilter.Union(newSpanIdsToFilter).ToList();
spans = spans.Except(newSpansToFilter).ToList();
return(FilterSpans(spans, spanIdsToFilter));
}
/// <summary>
/// Sends an API query to Ontraport and deserializes the result into an object.
/// </summary>
/// <typeparam name="T">The expected response data type. Set to JsonElement to parse manually. Set to Object to discard output.</typeparam>
/// <param name="endpoint">The URL endpoint, excluding that goes after https://api.ontraport.com/1/ </param>
/// <param name="method">The web request method.</param>
/// <param name="encodeJson">True to encode the request as Json, false to encode as URL query.</param>
/// <param name="values">Values set by the method type.</param>
/// <param name="returnNotFoundAsNull">If true, response code 404 will be returned as null instead of an exception.</param>
/// <param name="cancellationToken">The cancellation token to cancel operation.</param>
/// <returns>An ApiResponse of the expected type.</returns>
/// <exception cref="InvalidOperationException">There was an error while sending or parsing the request.</exception>
/// <exception cref="HttpRequestException">There was an HTTP communication error or Ontraport returned an error.</exception>
/// <exception cref="TaskCanceledException">The request timed-out or the user canceled the request's Task.</exception>
protected async Task <T?> RequestAsync <T>(string endpoint, HttpMethod method, bool encodeJson, IDictionary <string, object?>?values = null, bool returnNotFoundAsNull = false, CancellationToken cancellationToken = default)
where T : class
{
using var response = await SendRequestAsync(endpoint, method, encodeJson, values, returnNotFoundAsNull, cancellationToken).ConfigureAwait(false);
if (response == null)
{
return(null);
}
using var responseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
// Log response.
if (_logger?.IsEnabled(LogLevel.Trace) == true)
{
using var logReader = new StreamReader(responseStream, Encoding.UTF8, true, 512, true);
var logMsg = logReader.ReadToEnd();
_logger?.LogInformation(logMsg);
responseStream.Seek(0, SeekOrigin.Begin);
}
if (typeof(T) == typeof(object))
{
return((T?)null);
}
else
{
// Parse response.
try
{
var result = await JsonSerializer.DeserializeAsync <ApiResponse <T> >(responseStream, OntraportSerializerOptions.Default, CancellationToken.None).ConfigureAwait(false);
if (result.Code != 0)
{
throw new InvalidOperationException(Res.ResponseErrorCode.FormatInvariant(result.Code));
}
if (result.Data == null)
{
throw new InvalidOperationException(Res.InvalidResponseData);
}
return(result.Data !);
}
catch (JsonException ex)
{
throw new InvalidOperationException(Res.InvalidResponseData, ex);
}
}
}
public DefaultTypeConvertibleService(IEnumerable<ITypeConvertibleProvider> providers, ILogger<DefaultTypeConvertibleService> logger)
{
_logger = logger;
providers = providers.ToArray();
if (_logger.IsEnabled(LogLevel.Debug))
_logger.Debug($"发现了以下类型转换提供程序：{string.Join(",", providers.Select(p => p.ToString()))}。");
_converters = providers.SelectMany(p => p.GetConverters()).ToArray();
}
// ACQUIRE LOCK
public object?AcquireLock(string key, string operationId, TimeSpan timeout, ILogger?logger)
{
var semaphore = GetSemaphore(key, operationId, logger);
if (logger?.IsEnabled(LogLevel.Trace) ?? false)
{
logger.LogTrace("FUSION (K={CacheKey} OP={CacheOperationId}): waiting to acquire the LOCK", key, operationId);
}
var acquired = semaphore.Wait(timeout);
if (logger?.IsEnabled(LogLevel.Trace) ?? false)
{
logger.LogTrace("FUSION (K={CacheKey} OP={CacheOperationId}): LOCK acquired", key, operationId);
}
return(acquired ? semaphore : null);
}
public static void LogError(this ILogger logger, FlowContext flowContext, Exception exception, string messageTemplate, params object[] args)
{
if (logger?.IsEnabled(LogLevel.Error) != true)
{
return;
}
var argList = GetBaseArgList(flowContext, args);
logger.LogError(exception, FlowContextTemplate + messageTemplate, argList.ToArray());
}
// ACQUIRE LOCK ASYNC
public async Task <object?> AcquireLockAsync(string key, string operationId, TimeSpan timeout, ILogger?logger, CancellationToken token)
{
token.ThrowIfCancellationRequested();
var semaphore = GetSemaphore(key, operationId, logger);
if (logger?.IsEnabled(LogLevel.Trace) ?? false)
{
logger.LogTrace("FUSION (K={CacheKey} OP={CacheOperationId}): waiting to acquire the LOCK", key, operationId);
}
var acquired = await semaphore.WaitAsync(timeout, token).ConfigureAwait(false);
if (logger?.IsEnabled(LogLevel.Trace) ?? false)
{
logger.LogTrace("FUSION (K={CacheKey} OP={CacheOperationId}): LOCK acquired", key, operationId);
}
return(acquired ? semaphore : null);
}
private void LogError(HttpContextBase context, SecurityResult error)
{
_logger?.LogError("Actuator Security Error: {ErrorCode} - {ErrorMessage}", error.Code, error.Message);
if (_logger?.IsEnabled(LogLevel.Trace) == true)
{
foreach (var header in context.Request.Headers.AllKeys)
{
_logger?.LogTrace("Header: {HeaderKey} - {HeaderValue}", header, context.Request.Headers[header]);
}
}
}
public MeshPrimitive GenerateTriangleMesh(IEnumerable <GeoPoint> points, List <int> indices, IEnumerable <Vector4> colors = null, PBRTexture texture = null)
{
Stopwatch sw = null;
if ((_logger?.IsEnabled(LogLevel.Trace)).GetValueOrDefault(false))
{
sw = Stopwatch.StartNew();
_logger.LogTrace("Baking points...");
}
var pointsList = points.ToVector3().ToList();
MeshPrimitive mesh = GenerateTriangleMesh(pointsList, indices, colors, texture);
if ((_logger?.IsEnabled(LogLevel.Trace)).GetValueOrDefault(false))
{
sw.Stop();
_logger.LogTrace($"Baking points done in {sw.Elapsed:g}");
}
return(mesh);
}
private static void FilteredLog(ILogger logger, LogLevel level, string message, Exception exception = null, Customer customer = null)
{
//don't log thread abort exception
if (exception is System.Threading.ThreadAbortException)
return;
if (logger.IsEnabled(level))
{
string fullMessage = exception == null ? string.Empty : exception.ToString();
logger.InsertLog(level, message, fullMessage, customer);
}
}
public static void AddOrUpdateIdentifiedItem <TApi, TStore>(
this DbSet <TStore> dbSet,
TApi data,
DateTime lastObservedUtc,
ILogger logger
)
where TApi : IdentifiedItem
where TStore : IdentifiedStoreItem
{
if (dbSet == null)
{
throw new ArgumentNullException(nameof(dbSet));
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
var storeItem = dbSet.FirstOrDefault(si => si.Id == data.Id);
if (storeItem != null)
{
// Update an existing entry
if (logger?.IsEnabled(LogLevel.Trace) == true)
{
logger.LogTrace($"Updating existing {typeof(TStore).Name} with id {storeItem.Id} ({storeItem.DatamartId})");
}
// Map from data onto the existing storeItem which EF internal tracker will work out whether anything changed
storeItem = DatamartClient.MapperInstance.Map(data, storeItem);
storeItem.DatamartLastObservedUtc = lastObservedUtc;
return;
}
if (logger?.IsEnabled(LogLevel.Trace) == true)
{
logger.LogTrace($"Adding new {typeof(TStore).Name} with id {data.Id}");
}
// Add a new entry
dbSet.Add(DatamartClient.MapperInstance.Map <TApi, TStore>(data));
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="jsRuntime">The <see cref="IJSRuntime"/> to use for performing JavaScript interop operations.</param>
/// <param name="options">The options to be passed down to the underlying JavaScript library handling the authentication operations.</param>
/// <param name="navigation">The <see cref="NavigationManager"/> used to generate URLs.</param>
/// <param name="accountClaimsPrincipalFactory">The <see cref="AccountClaimsPrincipalFactory{TAccount}"/> used to generate the <see cref="ClaimsPrincipal"/> for the user.</param>
/// <param name="logger">The logger to use for login authentication operations.</param>
public RemoteAuthenticationService(
IJSRuntime jsRuntime,
IOptionsSnapshot <RemoteAuthenticationOptions <TProviderOptions> > options,
NavigationManager navigation,
AccountClaimsPrincipalFactory <TAccount> accountClaimsPrincipalFactory,
ILogger <RemoteAuthenticationService <TRemoteAuthenticationState, TAccount, TProviderOptions> > logger)
{
JsRuntime = jsRuntime;
Navigation = navigation;
AccountClaimsPrincipalFactory = accountClaimsPrincipalFactory;
Options = options.Value;
_loggingOptions = new JavaScriptLoggingOptions(logger?.IsEnabled(LogLevel.Debug) ?? false, logger?.IsEnabled(LogLevel.Trace) ?? false);
}
public static void LogContentType(this ILogger logger, IHeaderDictionary requestHeaders, string contentType)
{
logger?.LogTrace("setting contentType to {0}", contentType);
var logTrace = logger?.IsEnabled(LogLevel.Trace);
if (logTrace.GetValueOrDefault())
{
foreach (var header in requestHeaders)
{
logger.LogTrace("Header: {0} - {1}", header.Key, header.Value);
}
}
}
public void SetEntry <TValue>(string operationId, string key, FusionCacheMemoryEntry entry, FusionCacheEntryOptions options)
{
var memoryOptions = options.ToMemoryCacheEntryOptions();
options.MemoryOptionsModifier?.Invoke(memoryOptions, entry.GetValue <TValue>());
if (_logger?.IsEnabled(LogLevel.Debug) ?? false)
{
_logger.LogDebug("FUSION (K={CacheKey} OP={CacheOperationId}): saving entry in memory {Options} {Entry}", key, operationId, memoryOptions.ToLogString(), entry.ToLogString());
}
_cache.Set <FusionCacheMemoryEntry>(key, entry, memoryOptions);
}
/// <summary>
/// Used to retrieve the final log level setting. This is a "runtime" setting that is checking the result AFTER
/// accounting for launchSettings, appSettings, and environment variable settings.
/// </summary>
/// <param name="level">A log level. If that level is enabled, returns true. False otherwise.</param>
/// <returns></returns>
public static bool CheckLogLevel(LogLevel level)
{
var result = logger?.IsEnabled(LogLevel.Debug);
if (result.HasValue)
{
return(result.Value);
}
else
{
return(false);
}
}
private static void FilteredLog(ILogger logger, LogLevel level, string message, Exception exception = null,
User user = null)
{
//No se guarda el registro cuando es de un hilo de una excepcion de abort
if (exception is ThreadAbortException)
return;
if (logger.IsEnabled(level))
{
var fullMessage = exception == null ? string.Empty : exception.ToString();
logger.InsertLog(level, message, fullMessage, user);
}
}
// ACQUIRE LOCK ASYNC
public async Task <object?> AcquireLockAsync(string key, string operationId, TimeSpan timeout, ILogger?logger, CancellationToken token)
{
token.ThrowIfCancellationRequested();
var idx = GetLockIndex(key);
var semaphore = _lockPool[idx];
if (logger?.IsEnabled(LogLevel.Trace) ?? false)
{
logger.LogTrace("FUSION (K={CacheKey} OP={CacheOperationId}): trying to fast-acquire the LOCK", key, operationId);
}
var acquired = semaphore.Wait(0);
if (acquired)
{
_lockPoolKeys[idx] = key;
if (logger?.IsEnabled(LogLevel.Trace) ?? false)
{
logger.LogTrace("FUSION (K={CacheKey} OP={CacheOperationId}): LOCK fast-acquired", key, operationId);
}
return(semaphore);
}
if (logger?.IsEnabled(LogLevel.Trace) ?? false)
{
logger.LogTrace("FUSION (K={CacheKey} OP={CacheOperationId}): LOCK already taken", key, operationId);
}
var key2 = _lockPoolKeys[idx];
if (key2 != key)
{
if (logger?.IsEnabled(LogLevel.Trace) ?? false)
{
logger.LogTrace("FUSION (K={CacheKey} OP={CacheOperationId}): LOCK " + (key2 is null ? "maybe " : string.Empty) + "acquired for a different key (current key: " + key + ", other key: " + key2 + ")", key, operationId);
}
Interlocked.Increment(ref _lockPoolCollisions);
}
if (logger?.IsEnabled(LogLevel.Trace) ?? false)
{
logger.LogTrace("FUSION (K={CacheKey} OP={CacheOperationId}): waiting to acquire the LOCK", key, operationId);
}
acquired = await semaphore.WaitAsync(timeout, token).ConfigureAwait(false);
_lockPoolKeys[idx] = key;
if (logger?.IsEnabled(LogLevel.Trace) ?? false)
{
logger.LogTrace("FUSION (K={CacheKey} OP={CacheOperationId}): LOCK acquired", key, operationId);
}
return(acquired ? semaphore : null);
}
/// <summary> Unregister specified interceptor type
/// </summary>
/// <param name="interceptorType">interceptor type</param>
/// <param name="logger">logger</param>
/// <returns>true if interceptor was previously registered</returns>
public bool Unregister(Type interceptorType, ILogger logger = null)
{
if (null == interceptorType)
{
throw new ArgumentNullException("interceptorType");
}
string key = GetKey(interceptorType);
bool res = _interceptors.Remove(key);
if (res && logger?.IsEnabled(LogLevel.Information) == true)
{
logger.LogInformation($"Unregister interceptor: {key}");
}
return(res);
}
protected string GetErrorJson(object responseObject, ILogger logger)
{
if (responseObject is ErrorCollection errorCollection)
{
return(errorCollection.GetJson());
}
else
{
if (logger?.IsEnabled(LogLevel.Information) == true)
{
logger.LogInformation("Response was not a JSONAPI entity. Serializing as plain JSON.");
}
return(JsonConvert.SerializeObject(responseObject));
}
}
public async ValueTask <SkillRequest> ParseHttpRequestAsync(HttpRequest httpRequest)
{
if (httpRequest.ContentLength == null || httpRequest.ContentLength <= 0)
{
throw new InvalidDataException("Request body is missing.");
}
if (httpRequest.ContentLength > ContentLengthLimit)
{
throw new InvalidDataException("Request body is too large.");
}
if (string.IsNullOrEmpty(_skillionConfiguration.SkillId) &&
_skillionConfiguration.AlwaysValidateSkillRequest)
{
throw new Exception(
"Unable to process request. Always validate skill id is true and skill id is missing");
}
var rawJsonRequest = await ParseBodyToRequestAsync(httpRequest.Body);
if (_logger?.IsEnabled(LogLevel.Debug) ?? false)
{
_logger?.LogDebug(rawJsonRequest.ToString(Formatting.Indented));
}
var skill = rawJsonRequest.ToObject <SkillRequest>();
if (_webHostEnvironment.IsDevelopment() && !_skillionConfiguration.AlwaysValidateSkillRequest)
{
return(skill);
}
if (skill.Context.System.Application.ApplicationId != _skillionConfiguration.SkillId)
{
throw new Exception("Invalid application id.");
}
if (!await IsValidRequestAsync(httpRequest, skill, rawJsonRequest.ToString(Formatting.None)))
{
throw new Exception("Invalid request. Check timestamp or signature.");
}
return(skill);
}
private static void FilteredLog(ILogger logger, LogLevel level, string message,
Exception exception = null, Customer customer = null, bool stopException = true)
{
// không log thông điệp khi ngoại lệ là ThreadAbortException
if (exception is ThreadAbortException) return;
try
{
if (logger.IsEnabled(level)) // nếu cho phép ghi log với kiểu level
{
string fullMessage = exception == null ? string.Empty : exception.ToString();
logger.InsertLog(level, message, fullMessage, customer);
}
}
catch (Exception)
{
if (!stopException) throw;
}
}
public IEnumerable <TdsToken> GetResponse()
{
var tokens = GetResponseStream().ToList();
if (_logger?.IsEnabled(LogLevel.Debug) ?? false)
{
var s = new StringBuilder();
s.AppendLine($"Read response with {tokens.Count} tokens:");
foreach (var t in tokens)
{
s.AppendLine(t.ToShortString());
}
_logger.LogDebug(s.ToString());
}
return(tokens);
}
public static bool TryReadCustomAuthorization(
this MessageReceivedContext context,
JwtBearerOptions options,
TetraPakApiAuthConfig authConfig,
ILogger logger,
out string authorization)
{
using (logger?.BeginScope($"Looking for authorization in header: {authConfig.AuthorizationHeader}"))
{
if (!authConfig.IsCustomAuthorizationHeader)
{
logger.Debug("Default authorization header is in use");
authorization = null;
return(false);
}
authorization = context.Request.Headers[authConfig.AuthorizationHeader];
var isTokenAvailable = !string.IsNullOrWhiteSpace(authorization);
var isJwtToken = authorization.TryParseToJwtSecurityToken(out var jwt);
if (!logger?.IsEnabled(LogLevel.Debug) ?? false)
{
return(isTokenAvailable);
}
logger.Debug($"Received message: {context.Request.Path.Value}");
if (!isTokenAvailable)
{
logger.Debug("No authorization found");
return(false);
}
if (isJwtToken)
{
logger.Debug($"Received JWT: \n{jwt.ToDebugString()}");
logger.Debug($"Environment: {authConfig.Environment}");
logger.Debug($"Discovery document URL: {options.MetadataAddress}");
return(true);
}
logger.Debug($"Received token: \n{authorization}");
return(true);
}
}
/// <summary> Register specified interceptor
/// </summary>
/// <param name="interceptor">interceptor</param>
/// <param name="logger">logger</param>
/// <exception cref="ArgumentException">
/// Specified interceptor already registered
/// </exception>
public void Register(global::NHibernate.IInterceptor interceptor, ILogger logger = null)
{
if (null == interceptor)
{
throw new ArgumentNullException("interceptor");
}
UnregisterDefault();
try {
string key = GetKey(interceptor);
_interceptors.Add(key, interceptor);
if (logger?.IsEnabled(LogLevel.Information) == true)
{
logger.LogInformation($"Register interceptor: {key}");
}
} finally {
RegisterDefault();
}
}
protected SubscriptionService(
StreamStoreBase streamStoreClient,
string subscriptionName,
ICheckpointStore checkpointStore,
IJsonEventSerializer eventSerializer,
IEnumerable <IEventHandler> projections,
ILoggerFactory?loggerFactory = null,
ProjectionGapMeasure?measure = null
)
{
StreamStoreClient = streamStoreClient;
_checkpointStore = checkpointStore;
_eventSerializer = eventSerializer;
_subscriptionName = subscriptionName;
_measure = measure;
_projections = projections.Where(x => x.SubscriptionGroup == subscriptionName).ToArray();
_log = loggerFactory?.CreateLogger($"StreamSubscription-{subscriptionName}");
_debugLog = _log?.IsEnabled(LogLevel.Debug) == true ? _log.LogDebug : null;
}
// RELEASE LOCK ASYNC
public void ReleaseLock(string key, string operationId, object?lockObj, ILogger?logger)
{
if (lockObj is null)
{
return;
}
try
{
((SemaphoreSlim)lockObj).Release();
}
catch (Exception exc)
{
if (logger?.IsEnabled(LogLevel.Warning) ?? false)
{
logger.LogWarning(exc, "FUSION (K={CacheKey} OP={CacheOperationId}): an error occurred while trying to release a SemaphoreSlim in the reactor", key, operationId);
}
}
}
/// <inheritdoc/>
public IFusionCache SetupDistributedCache(IDistributedCache distributedCache, IFusionCacheSerializer serializer)
{
if (distributedCache is null)
{
throw new ArgumentNullException(nameof(distributedCache));
}
if (serializer is null)
{
throw new ArgumentNullException(nameof(serializer));
}
_dca = new DistributedCacheAccessor(distributedCache, serializer, _options, _logger);
if (_logger?.IsEnabled(LogLevel.Debug) ?? false)
{
_logger.LogDebug("FUSION: setup distributed cache (CACHE={DistributedCacheType} SERIALIZER={SerializerType})", distributedCache.GetType().FullName, serializer.GetType().FullName);
}
return(this);
}
private byte[] SerializeTraces(RootSpan trace)
{
if (_logger?.IsEnabled(LogLevel.Debug) ?? false)
{
using (var writer = new StringWriter())
{
Serializer.Serialize(writer, new[] { trace.Spans });
writer.Flush();
_logger?.LogDebug("Preparing to put {SpanJson}", writer.ToString());
}
}
using (var ms = new MemoryStream())
using (var writer = new StreamWriter(ms, Encoding))
{
Serializer.Serialize(writer, new[] { trace.Spans });
writer.Flush();
return(ms.ToArray());
}
}
public PublishConfirmableChannel(IModel channel, TimeSpan?confirmTimeout = null, ILogger?logger = null)
{
_channel = channel ?? throw new ArgumentNullException(nameof(channel));
_confirmTimeout = confirmTimeout ?? TimeSpan.FromSeconds(10);
if (_channel.IsClosed)
{
throw new InvalidOperationException("Channel already closed!");
}
_channel.ConfirmSelect();
_channel.ModelShutdown += OnModelShutdown;
_channel.BasicAcks += OnBasicAcks;
_channel.BasicNacks += OnBasicNacks;
_channel.BasicReturn += OnBasicReturn;
_logger = logger;
_publishTasks = new ConcurrentDictionary <ulong, PublishTaskInfo>();
_logTraceEnabled = logger?.IsEnabled(LogLevel.Trace) ?? false;
}
protected SubscriptionService(
EventStoreClient eventStoreClient,
string subscriptionId,
ICheckpointStore checkpointStore,
IEventSerializer eventSerializer,
IEnumerable<IEventHandler> eventHandlers,
ILoggerFactory? loggerFactory = null,
SubscriptionGapMeasure? measure = null
) {
EventStoreClient = eventStoreClient;
_checkpointStore = checkpointStore;
_eventSerializer = eventSerializer;
_subscriptionId = subscriptionId;
_measure = measure;
_projections = eventHandlers.Where(x => x.SubscriptionId == subscriptionId).ToArray();
_log = loggerFactory?.CreateLogger($"StreamSubscription-{subscriptionId}");
_debugLog = _log?.IsEnabled(LogLevel.Debug) == true ? _log.LogDebug : null;
}
private static void FilteredLog(ILogger logger, LogLevel level, Exception exception, string format, object[] objects) {
if (logger.IsEnabled(level)) {
logger.Log(level, exception, format, objects);
}
}
public override async Task ExecuteAsync(
IRelationalConnection connection,
ILogger logger,
CancellationToken cancellationToken = default(CancellationToken))
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(logger, nameof(logger));
var commandText = GetCommandText();
using (var storeCommand = CreateStoreCommand(commandText, connection))
{
if (logger.IsEnabled(LogLevel.Verbose))
{
logger.LogCommand(storeCommand);
}
try
{
using (var reader = await storeCommand.ExecuteReaderAsync(cancellationToken))
{
await ConsumeAsync(reader, cancellationToken);
}
}
catch (DbUpdateException)
{
throw;
}
catch (Exception ex)
{
throw new DbUpdateException(RelationalStrings.UpdateStoreException, ex);
}
}
}
public override async Task<int> ExecuteAsync(
RelationalTransaction transaction,
RelationalTypeMapper typeMapper,
DbContext context,
ILogger logger,
CancellationToken cancellationToken = default(CancellationToken))
{
Check.NotNull(transaction, nameof(transaction));
Check.NotNull(typeMapper, nameof(typeMapper));
Check.NotNull(context, nameof(context));
Check.NotNull(logger, nameof(logger));
var commandText = GetCommandText();
Debug.Assert(ResultSetEnds.Count == ModificationCommands.Count);
var commandIndex = 0;
using (var storeCommand = CreateStoreCommand(commandText, transaction.DbTransaction, typeMapper, transaction.Connection?.CommandTimeout))
{
if (logger.IsEnabled(LogLevel.Verbose))
{
logger.LogCommand(storeCommand);
}
try
{
using (var reader = await storeCommand.ExecuteReaderAsync(cancellationToken).WithCurrentCulture())
{
var actualResultSetCount = 0;
do
{
commandIndex = ModificationCommands[commandIndex].RequiresResultPropagation
? await ConsumeResultSetWithPropagationAsync(commandIndex, reader, context, cancellationToken)
.WithCurrentCulture()
: await ConsumeResultSetWithoutPropagationAsync(commandIndex, reader, context, cancellationToken)
.WithCurrentCulture();
actualResultSetCount++;
}
while (commandIndex < ResultSetEnds.Count
&& await reader.NextResultAsync(cancellationToken).WithCurrentCulture());
Debug.Assert(commandIndex == ModificationCommands.Count, "Expected " + ModificationCommands.Count + " results, got " + commandIndex);
#if DEBUG
var expectedResultSetCount = 1 + ResultSetEnds.Count(e => e);
expectedResultSetCount += ResultSetEnds[ResultSetEnds.Count - 1] ? -1 : 0;
Debug.Assert(actualResultSetCount == expectedResultSetCount, "Expected " + expectedResultSetCount + " result sets, got " + actualResultSetCount);
#endif
}
}
catch (DbUpdateException)
{
throw;
}
catch (Exception ex)
{
throw new DbUpdateException(
Strings.UpdateStoreException,
context,
ex,
commandIndex < ModificationCommands.Count ? ModificationCommands[commandIndex].Entries : new InternalEntityEntry[0]);
}
}
return commandIndex;
}
private static bool IsLogLevelEnabledCore(ILogger logger, LogLevel level)
{
return (logger != null && logger.IsEnabled(level));
}
public override void Execute(
IRelationalConnection connection,
ILogger logger)
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(logger, nameof(logger));
var commandText = GetCommandText();
using (var storeCommand = CreateStoreCommand(commandText, connection))
{
if (logger.IsEnabled(LogLevel.Verbose))
{
logger.LogCommand(storeCommand);
}
try
{
using (var reader = storeCommand.ExecuteReader())
{
Consume(reader);
}
}
catch (DbUpdateException)
{
throw;
}
catch (Exception ex)
{
throw new DbUpdateException(RelationalStrings.UpdateStoreException, ex);
}
}
}
private static void FilteredLog(ILogger logger, LogLevel level, string category, string format, object[] objects)
{
if (logger.IsEnabled(level))
{
logger.Log(level, category, format, objects);
}
}
private static void FilteredLog(ILogger logger, LogLevel level, Exception exception, Func<string> message)
{
if (logger.IsEnabled(level))
logger.Log(level, exception, message == null ? null : message());
}
