How Request Metrics is Built

Existing web performance tools don't cut it. They're too expensive and too complicated.
We want a service that is simple, affordable, and tells us when our pages and endpoints are slow.

That product doesn't exist, so we're building it, from scratch. And we're recording ourselves doing it.

Follow along and watch us build the web performance tool we want to use!

Breaking Out of Webpack Based Build Chains

Javascript build chains have gotten outrageously complicated. Let's create one that isn't.

Using the Beacon API

We need to capture performance data as the user is leaving the page. The Beacon gives us a reliable way to do that.

Using NGINX as a Queue for JSON Data

We need a queue to push our incoming performance data to. What we have is NGINX. Can we use NGINX and a custom log format to create a poor man's queue? You bet we can.

Episode 17: User Sign Up and Simple Access Control

Users can't actually sign up for an account. Today we fix that.

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

We need distributed session state because load balancing with sticky sessions is whack. Spoiler: We DON'T roll it ourselves.

Episode 15: Simple Cookie Based Authentication in ASP.NET Core

ASP.Net Core Identity is too magical. Will rolling authentication ourselves finally catch up to us?

Episode 14: Storing User Data In Redis

Redis only supports a handful of data types. Our data model has to fit within them. Are we crazy for trying this?

Episode 13: Testing In .NET Core Using NUnit

Testing framework arguments are almost as bad as tabs vs spaces. We've definitely picked the right one though. We're professionals.

Episode 12: Tweaking Systemd Services With Ansible

We thought we were done with infrastructure work. We were wrong.

Episode 11: Connecting to Redis in .NET Core 3.1

We've finally finished screwing around with basic groundwork. Today we start writing actually useful application code! First, can we connect to Redis?

Episode 10: Installing Redis Using An Ansible Galaxy Role

A pre-built playbook from Ansible Galaxy lets us easily install Redis. (Even we don't re-invent the wheel every time.)

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

A web application isn't much use if it isn't running. We'll hand in our neckbeard cards and copy+paste our way out of the problem.

Episode 8: Using Ansible to Configure NGINX for ASP.NET Core

It's best practice for ASP.NET Core applications to have a "real" webserver in front of them. We'll configure NGINX for the job using Ansible. We don't hate all best practices.

Episode 7: Using Ansible Roles for Common Linux Settings

Being Linux, some tweaks are needed right out of the box. Since we aren't proper neckbeards we rely on Ansible to ensure we get them right for each new machine.

Episode 6: Buying an SSL Certificate

How to buy a wildcard SSL certificate like grumpy old men.

Episode 5: Let's Encrypt? Let's Not.

We need a SSL certificate for our new site. Let's Encrypt makes it easy, right? Actually, it's complicated.

Episode 4: Deploying Code to Linux From TeamCity

We setup TeamCity to deploy the latest build to Linux using SSH. TeamCity is so slick, it can make anyone look like a wizard. Even us!

Episode 3.5: Basic Ansible With SSH Keys

We finally use our new SSH key to provision our Linux dev server with Ansible. Witness the "Hello World" of Ansible setups.

Episode 3: SSH Keys For Server Authentication

We create a new SSH key to use for authentication to a Linux dev server. We're rather unhip so we do it all from Windows.

Episode 2: Building the Code

We set up a repeatable CI build for our new .NET Core project so we can pretend we're professionals. We're old and crotchety though so we still use TeamCity instead of something hip.

Episode 1: File->New Project

Every journey begins with a single step. We wade through the myriad options of creating a new .NET Core project in 2020. We just make it look harder than it needs to be.

Episode 0: Introducing Request Metrics!

We introduce ourselves, and discuss what we're building and why.
Fun proposed architecture diagrams too!