FutureStack 2022: Recapping our product announcements. Read our blog.

Combine load testing and observability with Speedscale and New Relic One

Change your approach to scale testing with powerful microservice performance visibility

Published 4 min read

The traditional method for load testing requires a ton of steps: writing test cases, building non-prod environments, populating data, creating third-party API sandboxes, running tests, and reviewing reports. This is not a new struggle, and it's why software development teams have avoided load and integration testing in the past. Concepts like service virtualization came along in the early 2000s and brought some relief, but building mock services takes an enormous amount of time, and these concepts were designed for a previous generation of technology. As a result, they can be missing modern protocols and support for Kubernetes, containers, and other cloud native technologies. 

Today, with more than 1,000 different CNCF landscape technologies, development teams quickly build applications from numerous open source projects and rapidly push them into production, working in continuous integration (CI) environments. We need a new approach to scale testing, so it’s easier to gain confidence in how code will perform in real-word scenarios. 

In this blog post, I’ll show you why my cofounders and I created Speedscale and how the Speedscale quickstart visualizes traffic replay data into New Relic One dashboards so you can compare it with your telemetry data. 

The Speedscale story

Balancing the age-old struggle of speed with quality is something near and dear to our Speedscale hearts. Just a couple of years ago, Matt LeRay, Nate Lee, and I launched Speedscale with the goal of finally solving this dilemma for cloud native applications.

We really stepped back and considered our combined experiences in software development, quality assurance, service virtualization, and application monitoring (through the prism of a shared Georgia Tech value of innovation). We were part of the YCombinater Summer 2020 batch and publicly announced the launch on Hackernews. And we’ve been running full speed ahead ever since.

The solution: Speedscale traffic replay

Thanks to advances in cloud data warehousing, we can take a new approach to application performance by replaying previous traffic against new builds of code. Known as traffic replay, this approach means you can test applications using real traffic before you put them into production.

The real production system is messy and includes things like health checks, clients who do not upgrade their SDKs, and garbage data flowing in. With Speedscale traffic replay, teams can build enormous sets of test automation with the click of a button. And since it’s hard to provision the environment properly for these test scenarios, service mocks will automatically provide the right data for third-party APIs, and you can run it in your own containers.

Speedscale generates the traffic replay with appropriate data, auth, and mocks.

We built an alternative approach to solve the scale testing problem using Speedscale traffic replay. Much like application monitoring and observability, traffic replay observes live traffic and in this case creates test scripts, automated mocks, and unlimited scale scenarios. Rolling it out is a straightforward three-step process:

  1. API Observability—Use the deep data about how systems are called to understand how the service should be load tested.
  2. Analyze—Use big data processing across large data sets to automatically generate load test suites and service mocks without writing any scripts.
  3. Replay—Automatically replay this traffic locally on your machine or as part of the CI/CD release process.

How traffic replay can solve scale testing

Speedscale traffic replay enables the speed of automation with test environments at a scale usually only available in production. Integrate with CI using a simple GitOps workflow that can be defined with a couple of lines of configuration, no code required.

Integration with New Relic Instant Observability

So how does this fit with observability and New Relic? SRE teams deploy New Relic One because it can shine a spotlight on so many different parts of the application architecture. From Kubernetes clusters to containers to microservices, teams have more visibility than ever. Speedscale’s traffic replay shines a spotlight on microservice performance during software development with unlimited scalability. That’s powerful information when added to New Relic One telemetry data!

The Speedscale quickstart adds a reports dashboard that allows teams to see the results of traffic replay alongside all the other deep telemetry collected by New Relic One. Teams can see how a system performs to expectations spanning across all code—in dev (unreleased) and in production. 

For example, when a Speedscale report shows a low success rate from Speedscale, you can dig into the Error Analytics dashboard in New Relic. If the latency is spiking, you can drill down into APM data to understand the root cause.

The pre-built Speedscale quickstart dashboard shows services, snapshots, and a report list.

Exporting data from your Speedscale environment to New Relic One is simple: (see full integration instructions here):

  • Confirm Speedscale cloud account and config.yaml settings.
  • Grab the account ID and API key from New Relic One and use it to export a report with speedctl, a CLI tool used to interact with Speedscale cloud.
  • Go to the Speedscale quickstart, click Install quickstart, and follow the guided steps to get your reports dashboard.

Speedscale quickstart demo

Watch a demo of the Speedscale quickstart, CLI, and simulating API requests with traffic replay in this Nerdlog video.