Operations | Monitoring | ITSM | DevOps | Cloud

.NET

How to Extract Actionable Intelligence With C# Logging

When applications are deployed in the production environment, developers expect them to work smoothly without any performance issues. However, applications often experience unexpected bottlenecks, making it crucial to monitor applications. One of the simplest ways to monitor a C# application is to emit, save, and index log data for search, analysis, and troubleshooting. We’ll discuss how you can monitor your applications while making the most of C# logging.

Episode 16: Using Redis for Distributed Sessions in ASP.NET Core

We need distributed session. Spoiler: We DON'T roll it ourselves. In-memory sessions stop working as soon as there is more than one server. Most production environments have more than one server so the session issue needs to be dealt with. There are two options for sessions in a web farm. First, a load balancer can be used to lock each user on a specific box. This lets us continue to use in-memory sessions. The second is switching from in-memory to distributed session storage.

Parsing Query Strings in .NET Core

We recently needed to parse and modify some query strings while building Request Metrics. Query string parsing has never been pleasant in .NET, has it improved in .NET Core? We were familiar with HttpUtility.ParseQueryString() for the task, but that API has a major landmine. With the release of .NET Core, Microsoft took another swing at it. We figured we’d try the new way and see how they did! If you want the fully uncensored version, check out the video above.

Episode 13: Testing with NUnit in .NET Core

We've started writing code for Request Metrics. That code needs to be tested. We need a unit test framework for our .NET Core solution. We've used various frameworks on our .NET projects over the years, but enough has changed in .NET Core to require a small investigation into unit testing options. Ultimately, we settled on NUnit because of its good balance between simplicity and features.

Episode 11: Connecting to Redis with .Net Core and C#

We've finally finished screwing around with basic groundwork. Today we start writing actually useful application code! First, can we connect to Redis? Connecting to Redis implies some connection strings, so we'll create a basic environment based configuration while we're thinking about it.

Query string parsing in .NET: The old way vs. the new, which is better?

Query string parsing in ASP.NET has never been pleasant. The APIs were always a little weird and had some gotchas. Well, in .NET Core, Microsoft has taken another stab at a query string parsing API. Now, remember, they've had over a decade to come up with something better.... have they managed to improve things? Let's find out.

Episode 9: Running ASP.NET Core Applications Using Systemd and Ansible

A web application isn't much use if it isn't running. We hand in our neckbeard cards and copy+paste our way out of the problem. Last episode, we configured NGINX to act as a reverse proxy for our Asp.Net Core application. We tested our setup by manually running the .Net Core app from an SSH session. Today we'll fix that stop-gap step by running our application as a service with systemd. We'll add the new service by running a few tasks in Ansible.

Episode 8: Configuring NGINX with Ansible to Support ASP.NET Core

ASP.NET Core applications have a built-in webserver called Kestrel. This internal webserver is not intended to serve requests directly. It must be placed behind a production quality webserver such as NGINX or IIS. We use Ansible to provision NGINX on our Linux server.

.NET Developer Finds Latent Bugs with Prefix

Rostyslav Kosmirak is a .NET developer from Ivano-Frankivsk, Ukraine using Rider and Visual Studio IDE. Kosmirak was not looking for a Dynamic Code Profiler when he came across Prefix. Kosmirak explains that initially he was searching through Google for a log management system when he stumbled on Prefix. Upon downloading, Kosmirak discovered hidden performance problems in his code before they manifested to actual performance problems.