How to get HttpContext from Controller

No, it is not the correct way to do it. you need to use Filter or middleware to do it. HttpContext class is always null in the constructor of a controller

Sample middleware code (for logging)

you can do whatever in this like read cookies or whatnot

public class LoggingMiddleware
{
    private static readonly TelemetryConfiguration telemetryConfiguration = TelemetryConfiguration.CreateDefault();
    private readonly TelemetryClient telemetryClient;
    private IConfiguration configuration;
    private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
    private readonly string appName;
    private readonly bool loggingEnabled;

    private readonly RequestDelegate _next;

    public LoggingMiddleware(RequestDelegate next, IConfiguration config)
    {
        _next = next;
        configuration = config;
        _recyclableMemoryStreamManager = new RecyclableMemoryStreamManager();
        telemetryConfiguration.InstrumentationKey =  configuration.GetValue<string>("ApplicationInsights:InstrumentationKey");
        telemetryClient = new TelemetryClient(telemetryConfiguration);
        appName = configuration.GetValue<string>("AppName");
        loggingEnabled = configuration.GetValue<bool>("Logging:LogRequestResponse"); 
    }

    public async Task Invoke(HttpContext httpContext)
    {
        if(loggingEnabled)
        {
            await LogRequest(httpContext);
            await LogResponse(httpContext);
        }
    }

    private async Task LogRequest(HttpContext context)
    {
        context.Request.EnableBuffering();

        await using var requestStream = _recyclableMemoryStreamManager.GetStream();
        await context.Request.Body.CopyToAsync(requestStream);

        string correlationId = context.Request.Headers.Keys.FirstOrDefault(h => h.ToLower() == "correlationid");
        if (correlationId == null) correlationId = string.Empty;
        if (context.Request.Path != "/")
        {
            telemetryClient.TrackEvent($"{appName}-RequestMiddleware", new Dictionary<string, string>
            {
                { "AppName", appName },
                { "CorrelationId" , correlationId },
                { "Method" , context.Request.Method },
                { "Scheme", context.Request.Scheme},
                { "Host", context.Request.Host.Value },
                { "Path", context.Request.Path },
                { "QueryString", context.Request.QueryString.Value },
                { "Request Body", ReadStreamInChunks(requestStream) }

            });
        }
        context.Request.Body.Position = 0;
    }

    private static string ReadStreamInChunks(Stream stream)
    {
        const int readChunkBufferLength = 4096;

        stream.Seek(0, SeekOrigin.Begin);

        using var textWriter = new StringWriter();
        using var reader = new StreamReader(stream);

        var readChunk = new char[readChunkBufferLength];
        int readChunkLength;

        do
        {
            readChunkLength = reader.ReadBlock(readChunk,
                                               0,
                                               readChunkBufferLength);
            textWriter.Write(readChunk, 0, readChunkLength);
        } while (readChunkLength > 0);

        return textWriter.ToString();
    }

    private async Task LogResponse(HttpContext context)
    {
        var originalBodyStream = context.Response.Body;

        await using var responseBody = _recyclableMemoryStreamManager.GetStream();
        context.Response.Body = responseBody;

        await _next(context);

        context.Response.Body.Seek(0, SeekOrigin.Begin);
        var text = await new StreamReader(context.Response.Body).ReadToEndAsync();
        context.Response.Body.Seek(0, SeekOrigin.Begin);
        if (context.Request.Path != "/")
        {
            telemetryClient.TrackEvent($"{appName}-ResponseMiddleware", new Dictionary<string, string> {
                {"Scheme", context.Request.Scheme},
                { "AppName", appName },
                {"Host", context.Request.Host.Value},
                {"Path" , context.Request.Path},
                {"QueryString", context.Request.QueryString.Value},
                {"Response Body" , text}
                });
        }
       await responseBody.CopyToAsync(originalBodyStream);
    }
}


// Extension method used to add the middleware to the HTTP request pipeline.
public static class LoggingMiddlewareExtensions
{
    public static IApplicationBuilder UseLoggingMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<LoggingMiddleware>();
    }
}

No, you can't do it that way, controller constructors is danger zone (unless you know what you're doing) and should be used for DI only.

Instead, you should look at custom middleware: https://learn.microsoft.com/en-us/aspnet/core/fundamentals/middleware/write?view=aspnetcore-3.1

More info on asp.net Core life-cycles: https://www.c-sharpcorner.com/article/asp-net-core-mvc-request-life-cycle/