And it always seems we’re runnin’ out of time,
We’re out of control
Out of control
Out of control

“Out of Control,” The Chemical Brothers

When I talk to New Relic customers, the discussion often turns to four modern software architecture trends:

  1. Microservices
  2. Platform-as-a-Service (PaaS)
  3. In-memory databases
  4. Containerization

Some of our customers are simply trying to understand these trends and why they matter. Others have seen the benefits and already dived in, but have encountered a level of complexity that is difficult to control. Thankfully, the New Relic Software Analytics Platform has added a quartet of features and associations designed to help you tame the complexity of modern software architectures:

  • Service Maps
  • Database dashboard
  • Docker monitoring
  • Cloud Foundry Foundation membership

Exploring the trends in Modern Software

Despite their “modern” label, most of these trends are not exactly new. Microservices is an evolution of Service Oriented Architecture (SOA) from a decade ago, which in turn grew out of CORBA from the early ’90s. PaaS was popularized by Heroku back in 2007. In-memory databases first appeared in the mid-’90s. And containerization has its origins in chroot jails, which date back to 1982, when Michael Jackson’s Thriller topped the charts:

But even though these trends have been gestating for years (or decades, in some cases), they’re particularly relevant today because their adoption has now hit critical mass—driven, I believe, by their promise of increased developer productivity.

Microservices are finally achieving the dream of letting developer teams independently build a component once, and making it available to use across many applications without the previous decade’s WS-* standardpalooza. Reuse matters because companies need to build versions of an app for the Web as well as multiple operating systems for phones, tablets, and wearables. Independence matters because it enables teams to move quickly and do what they need to do to enable the business.

Containers, in particular Docker, are addressing another long-standing industry pain point: How to easily move applications from development to production, and across production environments. You can spin up a new Docker container in seconds with a single command (docker run). Since containers consume a fraction of the memory and disk of a traditional virtual machine, you don’t need to spend as much time hunting down space on an available server, or budget to pay your favorite Infrastructure-as-a-Service provider.

PaaS—including Cloud Foundry, Apprenda, IBM Bluemix, and others—frees developers from the drudgery of setting up an application infrastructure. It’s not just the installation and configuration of app servers, Web servers, and databases, but also stitching them together to form a cohesive app platform—while keeping everything up to date, performant, and secure. With Cloud Foundry, all that effort is replaced with a single deploy command: cf push <appname>.

In-memory databases provide a low-effort way for developers to speed up and scale their applications. This is because accessing data from memory typically takes about 1% of the time it does to access from disk. Few investments in developer time pay off as well as figuring out how to use fast in-memory databases to complement slower, traditional disk-bound SQL databases. This is why Twitter runs its real-time service in part with an in-memory database (Redis), and why Lamba Architecture is a hot topic among app architects.

Modern software architecture

In summary, we’re seeing wholesale shifts in what comprises a modern software architecture: from a relatively small number of monolithic apps to a larger number of microservices, from app servers to PaaS, from a data tier of disk-bound databases to a mix of in-memory and traditional databases, and from a relatively small number of physical or virtual machines to a larger number of containers.

Increasingly, a modern architecture consists of microservices running in a PaaS, using heterogenous data tiers, all of which run in containers:

modern software chart

But there’s a downside to all of these trends: complexity.

Microservices can rapidly multiply in number—one of our customers has more than 4,000 microservices in production! Container counts can mushroom thanks to that handy docker run command, and, as discussed on Network World, cattle-style management means that containers can have short life spans. Similarly, app instances can proliferate on PaaS thanks to cf push. And getting in-memory caches and traditional databases to work together is tricky when you consider the architectural implications of CAP theorem and ACID.

The New Relic Software Analytics Platform

So how do you gain the productivity of modern architectures without falling victim to their complexity? There’s no silver bullet, but new features in the New Relic Software Analytics Platform can help:

Service Maps let you monitor the performance of the microservices you’re responsible for and understand the complexity of the architecture that you’re working within. We’ve worked hard to ensure that Service Maps provide relevance by making it easy to view only the microservices that matter to you, and hiding those that don’t. Stevan Arychuk, APM product manager, has a great post that goes into further detail.

Docker monitoring puts Docker container performance in the context of app performance. Without this connection, you could have a meaningless collection of performance stats on an ever-growing number of containers, with no clarity on how any given container impacts app performance. Adam Larson, our Docker engineering manager, describes the new feature further in this blog post.

Database dashboards help developers and sysadmins view the unique performance data for each type of datastore in your architecture. You need this separation of metrics if you’re troubleshooting a heterogeneous data layer that includes (typically slower) SQL databases and (typically faster) in-memory data caches. Stevan blogged about this a couple of months ago, but it’s important to mention it again in the context of modern architecture complexity.

Streamlined alerting is critical for taming modern architecture complexity. Our new alerting platform rolls up all related violations into a single incident—and notifies you just once. That makes a big difference when you’re running hundreds or even thousands of microservices, containers, and app instances. Without incident rollup, you could face an alert storm of epic proportions. Alerts product manager Nate Heinrich explains this and the rest of our newly rebuilt alert platform here.

Cloud Foundry and New Relic have worked together for almost two years, since we made it dead-simple to monitor the performance of apps running on that PaaS. Today we are formalizing our commitment to Cloud Foundry by joining the Cloud Foundry Foundation, as described in this press release.

So while it might feel like modern architecture complexity can sometimes spin out of control, we’re doing our best to help restore a bit of sanity. We hope you like these new developments.

For more information, see:


Background image courtesy of

View posts by .

Interested in writing for New Relic Blog? Send us a pitch!