Make Your Logs Work for You

The days of logging in to servers and manually viewing log files are over. SolarWinds® Papertrail™ aggregates logs from applications, devices, and platforms to a central location.

View Technology Info

FEATURED TECHNOLOGY

Troubleshoot Fast and Enjoy It

SolarWinds® Papertrail™ provides cloud-based log management that seamlessly aggregates logs from applications, servers, network devices, services, platforms, and much more.

View Capabilities Info

FEATURED CAPABILITIES

Aggregate and Search Any Log

SolarWinds® Papertrail™ provides lightning-fast search, live tail, flexible system groups, team-wide access, and integration with popular communications platforms like PagerDuty and Slack to help you quickly track down customer problems, debug app requests, or troubleshoot slow database queries.

View Languages Info

FEATURED LANGUAGES

TBD - APM Integration Title

TBD - APM Integration Description

TBD Link

APM Integration Feature List

TBD - Built for Collaboration Title

TBD - Built for Collaboration Description

TBD Link

Built for Collaboration Feature List

Tips from the Team

Azure Web Apps Logging With Net 5—How-To

START FREE TRIAL

Fully Functional for 14 Days

Logging is an essential part of any application, no matter the tech stack or service to which you deploy. When things go wrong in production, logging might just save you from going blind when trying to fix the issue.

In this post, you’ll see how to implement logging for your .NET 5 Asp.NET app on Azure Web Apps.

There will be requirements if you want to follow along. We’ll assume you have the following:

  • A GitHub account
  • An Azure account
  • At least some familiarity with C#/.NET
  • Familiarity with the command line
  • The .NET SDK installed on your machine—by the time of this writing, the latest version is .NET 5.0, but 6.0 should come out in the next couple of months.

Got everything you need? Then let’s get started.

First, You Need an App

To start, you’ll need an app hosted on GitHub. For brevity’s sake, I won’t walk you through the app creation. Start by going to https://repo.new to create a new GitHub app (the link will redirect you to the login page in case you’re not already logged into your GitHub account).

Give the repository any name you like. Then, on the page shown in the following image, click on the highlighted button to copy those lines to your clipboard. They’ll be useful in a moment.

Afterward, go to this repo on GitHub and clone it or download it as a ZIP file and extract it. This is the sample app you’ll use.

Now, access the cloned or extracted folder. If you cloned the repo, get rid of the original Git folder:

rm -r -fo .git # if you're on Windows/ powershell
rm -rf .git # if you're on Linux

The commands above cut the cord to the original Git repo. You can now create your own repository with those files:

git init
git add --all
git commit -m "Initial commit"

Finally, paste the lines you copied earlier to push the files to your remote repository:

git remote add origin https://github.com/<YOUR-USERNAME>/<YOUR-REPO-NAME>.git
git branch -M main
git push -u origin main

Configure the Deployment to Azure

Now it’s time to configure continuous integration and continuous delivery (CI/CD) to Azure. Start by going to the Azure portal.

Creating an App

Click on the main menu and go to App Services:

Then, on the new screen, click Create:

You’ll be taken to yet another screen, where you’ll be able to configure your new web app:

Configuring the Application

Configure the app as follows:

  1. Subscription. Choose between the subscriptions available for you.
  2. Resource group. Choose the resource group, creating a new one if needed.
  3. Choose a name for your web app. The name isn’t very important; pick something short and easy to remember.
  4. Select a runtime stack. In my case, I picked .NET 5.0.
  5. Choose an operating system. I picked Windows.

Then, configure the remaining options. Choose a region for your app, an App Service Plan, and an SKU and size.

Then, click on Next:Deployment to configure the next step.

Configuring Deployment

The deployment configuration itself is quite easy:

  1. First, start by enabling continuous deployment.
  2. Then, select the GitHub account you’ll use, giving the necessary permissions to Azure.
  3. Afterward, select the organization. If you don’t have any organizations, this will be your GitHub username.
  4. Then, select the repository you want to associate with the Azure app.
  5. Finally, select the branch.

If you click on Preview file, you can get a glimpse of the GitHub action configurations Azure will generate for you:

If everything looks fine, you can click on Review + Create and then on Create. This will trigger a deployment.

Troubleshooting a Potential Problem

You should be able to navigate to your app’s URL and see the application. If you see a generic Azure page, something’s wrong.

In this case, go back to the portal. On the left navigation bar, click on Configuration—the first item under Settings:

On the new screen, go to the Default documents tab.

You’ll see a list of default documents. Make sure the first item is index.html. This should make the problem go away and ensure your actual app homepage is shown.

To check whether the continuous deployment is really working, make a change to the app and see if the live app is updated. In other words, in my case, I went to the view for the Index action on HomeController and changed the greeting to “Hello World!”:

Now that you have a working, live app with continuous deployment enabled, let’s see how we can enable logging.

Enable Logging

Enabling logging on Azure will require three simple steps. Step #1 is simply activating the setting on Azure Portal.

Go to your app’s page on the portal. On the left menu, click on App Service logs under Monitoring:

You’ll be taken to a screen where you can configure logging. Make sure you activate Application Logging (Filesystem). You’ll see a message saying, “Click here to install the ASP.NET Core site extension to enable Application Logging.”

Upon clicking on the message, you’ll be prompted with a yes-no dialogue. Click yes to continue. You’ll see a message saying the extension was successfully installed. Click on the Save button to finish the configuration.

For the next step, we’ll make the necessary changes to the code. Start by installing the necessary NuGet package.

# starting from the project's root folder
cd src/AzureLoggingDemo.Web
dotnet add package Microsoft.Extensions.Logging.AzureAppServices

Now for the code. Open the Program.cs file using Visual Studio Code or another text editor. Add the following line to your list of usings:

using Microsoft.Extensions.Logging.AzureAppServices;
using Microsoft.Extensions.DependencyInjection;

Now, edit your ConfigureHostBuilder method so it looks like this:

public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureLogging(logging =>
                    {
                        logging.ClearProviders();
                        logging.AddConsole();
                        logging.AddDebug();                        
                        logging.AddAzureWebAppDiagnostics();
                    })
                .ConfigureServices(services =>
                {
                    services.Configure<AzureFileLoggerOptions>(options =>
                    {
                        options.FileName = "first-azure-log";
                        options.FileSizeLimit = 50 * 1024;
                        options.RetainedFileCountLimit = 10;
                    });
                })
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });

Finally, we’re ready to log. Go to your HomeController and change its constructor to this:

public HomeController(ILoggerFactory loggerFactory)
{
    _logger = loggerFactory.CreateLogger<HomeController>();
    _logger.LogWarning("This is a WARNING message");
    _logger.LogInformation("This is an INFORMATION message");
}

If you run or debug your application, you’ll see the messages displayed on the console.

Now, commit and push all your changes:

git commit -am "Add logging"
git push

That’s pretty much it. Now you can simply visit your application using the URL you can see on your Azure dashboard. On the portal, click on “Log Stream” immediately below “App Services log” and you’ll see the log messages in real time.

Make the Best Out of Your Logging

Logging is one of the most important processes developers and teams can adopt when it comes to monitoring their apps. After all, software is complicated, and once it goes live, you never really know what could happen.

When things go wrong, having a proper logging strategy is often the difference between a quick and decisive investigation or a long and aimless one.

In this post, you’ve seen how to set up logging for an ASP.NET MVC application hosted on Azure. So what should your next steps be?

Education is always a great answer to this question. For instance, you might want to take a look at this useful post about best practices for C# logging.

Another suggestion: start looking into application log aggregation. Besides logging to regular destinations, such as a file or the console, you can also send your logs to a file aggregation tool such as SolarWinds® Papertrail.

With log aggregation, you can collect logs from many disparate sources across your organization, bringing them together for better visibility, quicker and easier troubleshooting, and the possibility of extracting valuable insights from them. Here’s a useful tutorial on how you can send your C# logs to Papertrail using NLog.

This post was written by Carlos Schults. Carlos is a consultant and software engineer with experience in desktop, web, and mobile development. Though his primary language is C#, he has experience with several languages and platforms. His main interests include automated testing, version control, and code quality.

Aggregate, organize, and manage your logs

  • Collect real-time log data from your applications, servers, cloud services, and more
  • Search log messages to analyze and troubleshoot incidents, identify trends, and set alerts
  • Create comprehensive per-user access control policies, automated backups, and archives of up to a year of historical data
START FREE TRIAL

Fully Functional for 30 Days

Let's talk it over

Contact our team, anytime.