ASP.NET CORE WEB API иногда не регистрируюсь ⇐ C#

[Anonymous]

У меня есть веб -API ASP.net Core 8. У меня есть странная проблема. Я также пишу журналы в понимании приложений, но иногда он ничего не регистрирует, но запись базы данных сделана. Также не существует исключений. Я не могу воспроизводить проблему локально при запуске в Visual Studio. Я даже добавил промежуточное программное обеспечение для журнала, но оно не входит в систему в этом случае. Я добавил журналы в самом начале конечной точки.public class MyActionController : BaseController
{
[SwaggerOperation(Tags = new[] { "Service Desk" })]
[HttpPost]
[Route(Predefined.ObjectsRoute)]
[ActionApi(
Name = "Set Objects",
Category = Constants.Category,
Provider = Constants.Provider,
EndpointsRequired = false,
SupportedPlatforms = new[] { AgentPlatform.Windows, AgentPlatform.Cloud }
)]
[AuthorizeAction]
public async Task PostObjects([FromBody] ObjectsRequestBody requestBody)
{
Logger.LogInfo("Logs");

app.UseWhen(
context => !context.Request.Path.StartsWithSegments($"{HealthCheckStrings.STARTUP_ROUTE}/{HealthCheckStrings.MANAGEMENT_WEBHOST_PROBE_SUFFIX}", StringComparison.OrdinalIgnoreCase) &&
!context.Request.Path.StartsWithSegments($"{HealthCheckStrings.READINESS_ROUTE}/{HealthCheckStrings.MANAGEMENT_WEBHOST_PROBE_SUFFIX}", StringComparison.OrdinalIgnoreCase) &&
!context.Request.Path.StartsWithSegments($"{HealthCheckStrings.LIVENESS_ROUTE}/{HealthCheckStrings.MANAGEMENT_WEBHOST_PROBE_SUFFIX}", StringComparison.OrdinalIgnoreCase),
builder => builder.UseMiddleware()
);

public class RequestSegregatorMiddleware
{
private readonly RequestDelegate _next;
private readonly IDiagnostics _diagnostics;
private readonly IServiceScopeFactory _serviceScopeFactory;

public RequestSegregatorMiddleware(
RequestDelegate next,
IDiagnostics diagnostics,
IServiceScopeFactory serviceScopeFactory)
{
_next = next;
_diagnostics = diagnostics;
_serviceScopeFactory = serviceScopeFactory;
}

public async Task InvokeAsync(HttpContext context)
{
using (var scope = _serviceScopeFactory.CreateScope())
{
var tokenDecoder = scope.ServiceProvider.GetRequiredService();
var strategyFactory = scope.ServiceProvider.GetRequiredService();

try
{
string token = context.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();
var (clientId, tenantId) = tokenDecoder.DecodeJwt(token);

var strategy = strategyFactory.GetStrategy(clientId);
var priority = strategy.DeterminePriority(context, clientId, tenantId);

context.Items["JobPriority"] = priority;
_diagnostics.LogInfo($"Request priority set to {priority} for ClientId: {clientId}, TenantId: {tenantId}");
}
catch (Exception ex)
{
_diagnostics.LogError($"Error in {nameof(RequestSegregatorMiddleware)}: {ex.Message}", ex);
}
}

await _next(context);
}
}

services.AddSingleton(context =>
{
var logger = context.GetService();
return new AutomationDiagnostics(context.GetService(), logger);
});

public class AutomationDiagnostics : IDiagnostics
{
private readonly ILogger _logger;
private readonly TelemetryClient _telemetryClient;

private static readonly string _identifier = typeof(AutomationDiagnostics).Name;

private static readonly string SERVICE_NAME = "ServiceName";

public ILogger Logger => _logger;

public AutomationDiagnostics(TelemetryClient telemetryClient, ILogger logger)
{
_telemetryClient = telemetryClient;
_logger = logger;
}

public virtual void LogInfo(string message, params object[] args)
{
Log(LogType.INFO, FormatString(message, args));
}

private string FormatString(string message, params object[] args)
{
if (args != null && args.Length > 0)
return string.Format(CultureInfo.InvariantCulture, message, args);

return message;
}

private string Log(LogType logType, string message, Exception exception = null)
{
string toLog = string.Empty;

try
{
Dictionary logProperties = CreateLogProperties(logType, message, exception);

object[] logValues = new object[logProperties.Count];

StringBuilder sb = new StringBuilder();

int i = 0;

foreach (var kvp in logProperties)
{
sb.Append("{" + kvp.Key + "} : ");
logValues[i++] = kvp.Value;
}

toLog = sb.ToString(); // $"{_identifier} : {message}";

switch (logType)
{
default:
_logger.LogInformation(toLog, logValues);
break;
}
}
catch (Exception ex)
{
toLog = $"{_identifier} error: {ex.Message}";
_logger.LogError(toLog);
}

return toLog;
}

private Dictionary CreateLogProperties(LogType logType, string message, Exception exception)
{
Dictionary logProperties = new Dictionary();
logProperties.Add(SERVICE_NAME, _identifier);
logProperties.Add("Message", message);
logProperties.Add("HostName", GetHostName());

if (exception != null)
{
string exceptionMessage = exception.Message;

StringBuilder innerExceptionsMessage = new StringBuilder();
var innerException = exception.InnerException;

while (innerException != null)
{
if (innerExceptionsMessage.Length > 0)
innerExceptionsMessage.Append(" / ");
innerExceptionsMessage.Append(innerException.Message);
innerException = innerException.InnerException;
}

string stackTrace = exception.StackTrace;

logProperties.Add("Exception", exceptionMessage);
logProperties.Add("InnerExceptions", innerExceptionsMessage.ToString());
logProperties.Add("StackTrace", stackTrace);
}
else if (logType == LogType.ERROR || logType == LogType.CRITICAL)
{
//string stackTrace = Environment.StackTrace;
//logProperties.Add("StackTrace", stackTrace);
}

return logProperties;
}

private string GetHostName()
{
try
{
return Dns.GetHostName();
}
catch (Exception)
{
return string.Empty;
}
}

#endregion
}
}

public class BaseController : ControllerBase
{
protected readonly IDiagnostics Logger;
protected readonly IExecutionContextFacade Context;

public BaseController(
IExecutionContextFacade context,
IOperationContextHelper operationContextHelper,
IDiagnostics logger)
{
Logger = logger;
Context = context;

var tenantId = Context.TenantId.ToString();

operationContextHelper.SetCurrentTenant(tenantId);
}
}

У меня также есть ActionFilter , который также не регистрируется в этом случае.
services.AddControllers(options =>
{
options.Filters.Add();
});

public class RequestLoggingFilter : IAsyncActionFilter
{
private readonly ILogger _logger;
private readonly ILaunchDarkly _launchDarklyHandler;
Guid _fakeTenantId = new Guid("11111111-1111-1111-1111-111111111111");
readonly List _verbs = new List() { "POST", "PUT", "DELETE", "PATCH" };

public RequestLoggingFilter(ILogger logger, ILaunchDarkly launchDarklyHandler)
{
_logger = logger;
_launchDarklyHandler = launchDarklyHandler;
}

public async Task GetPayload(ActionExecutingContext context)
{
var requestBody = "";
context.HttpContext.Request.Body.Position = 0;

using (var reader = new StreamReader(context.HttpContext.Request.Body, encoding: Encoding.UTF8, detectEncodingFromByteOrderMarks: false, leaveOpen: true))
{
requestBody = await reader.ReadToEndAsync();
context.HttpContext.Request.Body.Position = 0;
}

return requestBody;
}

async System.Threading.Tasks.Task IAsyncActionFilter.OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
try
{
if (_launchDarklyHandler.IsFeatureEnabled(LaunchDarklyConfig.RequestPayloadActionFilter, _fakeTenantId, false, false))
{
var requestPayload = await GetPayload(context);

_logger.LogDebug($"Request: {context.HttpContext.Request.Method} {context.HttpContext.Request.Path}");

if (requestPayload != null && requestPayload.Length != 0)
{
if (_verbs.Contains(context.HttpContext.Request.Method, StringComparer.OrdinalIgnoreCase))
{
_logger.LogDebug($"Request Body: {requestPayload}");
}
}
else
{
_logger.LogDebug($"Request Body: Empty");
}
}
}
catch (Exception e)
{
_logger.LogError($"Failed to Capture Request Body: {e.Message}");
}
finally
{
await next();
}
}
}


Подробнее здесь: https://stackoverflow.com/questions/797 ... -sometimes