Snippset Feed

In ASP.NET Core, you can configure logging levels to control the verbosity of logs across your application and third-party frameworks.

A common pattern is to set a default minimum log level (e.g., Warning) and enable verbose logging (Trace) only for your own application namespace.

Example configuration in appsettings.json or an environment-specific file:

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning",
      "Microsoft": "Warning",
      "System": "Warning",
      "YourAppNamespace": "Trace"
    }
  }
}

• "Default": "Warning" sets a baseline for all logs.
• "Microsoft" and "System" are explicitly set to Warning to reduce noise from framework logs.
• "YourAppNamespace": "Trace" enables detailed logging for your application code.

This ensures your app logs detailed information while keeping system logs concise and manageable.

Logging is a critical aspect of application monitoring and diagnostics. ASP.NET Core provides flexible logging configuration options to help you balance verbosity and noise across different environments and providers.

This series covers best practices for configuring logging levels, including:

• Setting baseline and application-specific log levels
• Customizing logging behavior per provider (e.g., Console, Application Insights)
• Tailoring logging configurations for different environments (Development, Production, etc.)

Explore the related Snipps below to implement a robust, maintainable logging strategy in your ASP.NET Core applications.

TryCombineUrl follows the .NET convention for “Try” methods by returning a bool indicating success and providing the result via an out parameter. This approach is ideal when logging failures explicitly or when avoiding exceptions is critical. It can be used in structured logging or conditional logging scenarios where fallback logic may be required.

public static class LoggingHelpers
{
    public static bool TryCombineUrl(Uri? baseAddress, string path, out string? fullUrl)
    {
        try
        {
            if (string.IsNullOrWhiteSpace(path))
            {
                fullUrl = baseAddress?.ToString() ?? string.Empty;
            }
            else if (baseAddress == null)
            {
                fullUrl = path;
            }
            else
            {
                fullUrl = new Uri(baseAddress, path).ToString();
            }
 
            return true;
        }
        catch
        {
            fullUrl = null;
            return false;
        }
    }
}

The CombineUrl method offers a safe, reusable way to concatenate a base URI and path string for logging purposes. It is wrapped in a try-catch block to avoid exceptions from malformed input, making it reliable for use in production logging. This method returns a string and can be placed inside a centralized LoggingHelpers class for consistent use across the codebase.

public static class LoggingHelpers
{
    public static string CombineUrl(Uri? baseAddress, string path)
    {
        try
        {
            if (string.IsNullOrWhiteSpace(path))  return baseAddress?.ToString() ?? string.Empty;
 
            if (baseAddress == null)  return path;
 
            return new Uri(baseAddress, path).ToString();
        }
        catch (Exception ex)
        {
            return $"[InvalidUrl: {ex.Message}]";
        }
    }
}

In structured logging within C#, it's common to log endpoint URLs that consist of a base address and a path. To ensure safe and consistent logging, developers should use a centralized utility method to combine these values without risking exceptions or malformed URLs. This Snipp outlines two recommended approaches for implementing this functionality in a logging-safe way.

Logging in C# is a critical practice for monitoring application behavior, diagnosing issues, and gaining operational insights. Whether building desktop applications, APIs, or cloud-native services, effective logging allows developers and operators to understand how the system behaves in real time and after the fact.

Getting clear and helpful answers from ChatGPT depends a lot on how you ask your questions. By using a few simple steps, you can guide the AI to give you exactly what you need—fast and easy. 

1. Clarify the Role:
   Start by telling ChatGPT what kind of expert or role it should take.
   Example prompt: “Please act as an experienced digital marketing consultant. I need advice to improve my social media.”

2. Explain the Situation:
   Give background information about your goal or project.
   Example prompt: “I’m preparing to launch a new product and want to find the best ways to reach my customers.”

3. Give Examples:
   Ask for sample answers or models to guide the response.
   Example prompt: “Show me three examples of Instagram posts with captions that are engaging.”

4. Choose the Tone and Style:
   Tell ChatGPT how you want the response to sound.
   Example prompt: “Use a friendly and simple tone that anyone can understand.”

5. Set the Response Format:
   Specify the length or layout you prefer.
   Example prompt: “Keep your answer under 150 words and use bullet points.”

To display JSON in a structured and readable format directly in PowerShell, you can pipe a JSON string through ConvertFrom-Json and then ConvertTo-Json with an appropriate -Depth parameter. This allows you to avoid using intermediary variables and outputs neatly formatted JSON directly to the console.

Example:

'{"name":"John","age":30,"address":{"street":"123 Main St","city":"Anytown"},"phones":["123-4567","987-6543"]}' 
| ConvertFrom-Json 
| ConvertTo-Json -Depth 10

Explanation:

• ConvertFrom-Json parses the raw JSON string into a PowerShell object.
• ConvertTo-Json re-serializes the object with proper indentation.
• The -Depth parameter ensures that nested objects are fully expanded in the output.

This approach is useful for quickly inspecting JSON structures without needing temporary variables or additional tools.

When handling tokens in .NET applications, it's essential to avoid logging them in full due to the potential exposure of sensitive information. A best practice is to redact tokens before logging by showing only a prefix and/or suffix.

Here’s a robust approach:

1. Redact tokens safely: Display only the first few and last few characters of the token, separated by ellipses (...). If the token is too short to show both, consider showing only the prefix followed by ..., or return a standardized warning.

2. Implement a helper method: Encapsulate redaction logic in a shared utility to ensure consistent and secure usage throughout the codebase.

public static string RedactToken(string token, int prefixLength = 6, int suffixLength = 4)
{
    if (string.IsNullOrEmpty(token))
        return "[null or empty token]";
 
    int minLengthForFullRedaction = prefixLength + suffixLength;
 
    if (token.Length >= minLengthForFullRedaction)
    {
        var prefix = token.Substring(0, prefixLength);
        var suffix = token.Substring(token.Length - suffixLength);
        return $"{prefix}...{suffix}";
    }
 
    int minLengthForPrefixOnly = prefixLength + 3; // For "..."
    if (token.Length >= minLengthForPrefixOnly)
    {
        var prefix = token.Substring(0, prefixLength);
        return $"{prefix}...";
    }
 
    return "[token too short to redact securely]";
}

3. Optional hashing for debugging: If correlation is needed without revealing the token, hash it using a secure algorithm (e.g., SHA256) and log only the hash.

By centralizing redaction in a reusable helper and applying consistent rules, applications can balance debugging needs with security best practices.

If you encounter issues with dual audio output:

• Update Drivers: Ensure all audio drivers are current to prevent compatibility problems.
• Check Connections: Verify that all audio devices are properly connected and recognized by the system.
• Test Sound: Conduct sound tests to confirm audio is playing through both outputs.
• Adjust Volume: Manage volume levels for each device to achieve balanced sound.
• Restart System: Reboot your computer if changes do not take effect immediately.

These steps can help resolve common issues related to multiple audio outputs.