×

At Rigor, we want to make continuous monitoring of API performance and functionality easy for everyone.

Earlier this year, we introduced a new API Check for monitoring API performance and reliability. Then, we wrote and published a free eBook about how to test and monitor APIs at scale. Today, we’re launching a set of exciting enhancements for API Check that will expand monitoring possibilities for our users.

What’s new?

Most importantly, API Check is now programmable. We added the ability to augment check steps with JavaScript, so you can adapt your API Checks for any type of flow or transaction. We also added support for testing XML-based APIs (such as SOAP). Finally, we made it easy to manage API testing at scale.

In this blog post we’ll outline each of the new features, so you can understand how they’ll make API Checks more powerful for you and your team.

New Check Step Type: JavaScript

Rigor’s API Checks are ideal for monitoring transactions of data between systems. Initially they included four simple types of steps: make requests, extract data, save variables, or make assertions. These step types act like basic building blocks. You can use them to build simple or robust API transactions.

Today we’re adding JavaScript steps to API Checks. This new step type will allow you to run JavaScript code, so you can access variables, run computations, and return data to be saved as new variables. This is a powerful addition that will make API Checks more flexible and robust. Here are some examples of purposes for new JavaScript steps:

Validate API Functionality with Logic

API Checks give users the ability to make Assert statements to validate the performance and functionality of an API Call. For example, it’s easy to assert that the response time is less than 500 ms. Or, you could assert that the RateLimit header is present and set to false. But if you need to use more complicated logic to validate the functionality of an API, you now have the ability to do so using the JavaScript step.

You can now use more customized logic and conditionals to test different properties of the API. This provides more flexibility to ensure that APIs are behaving properly.

complex-resp-check-update

 

Transform or Modify Data Between API Check Steps

When testing the API Check with Rigor users, we found a common scenario. Users needed the ability to transform the formats for strings of data.

For example, if you’re monitoring a flow of API calls where data is being extracted, saved, and re-used, you may need to send a timestamp or date to another API. But, what happens if the APIs use different date formats?

Now, you can use JavaScript steps to transform or mutate saved timestamps, dates, or other strings of data. Then, you can use transformed data strings in subsequent requests for APIs requiring specific formats.

mutate-data

Dynamically Update Test Data

Similar to how you might need to transform data formats to accommodate specific system requirements, you may need to adjust test steps for specific conditions such as location or runtime.

For example, if you’re testing an API for a store location lookup, you may need to submit dynamic zip codes based on the locations from which you’re testing. Or, perhaps you need to send over the exact longitude and latitude of a testing location in order to test an API that verifies location. Or, maybe you need to send different types of data during different time periods.

Whatever the case, JavaScript steps give you more control over what test data is sent at any given time from any specific testing location.

Learn more about how to use JavaScript steps in this Knowledge Base article: API Check JavaScript Step

Support for XML/SOAP-based APIs

API Check already allows you to send POST requests within an XML body. Now you can also extract data from XML responses using xPath. You can save data as variables, make assertions on that data, or use it in subsequent calls – just like you would for monitoring JSON APIs.

Expanded functionality for xPath in API Checks gives us the ability to monitor SOAP or XML-based APIs more fully. In the past we could have monitored the availability of these types of APIs. Now, we can also monitor the functionality.

xpath-extract

Learn more about what’s possible in the Knowledge Base documentation here: How to Create an API Check

Global Variables for Managing API Checks at Scale

As your team starts to monitor more and more APIs, you will inevitably find that you’re using the same types of data over and over again. For example, if you are monitoring APIs that require authentication, you may be repeatedly adding API tokens of user credentials into steps of requests. If you ever need to reset an API check or update those credentials, it could be time-consuming to manually edit and update every check referencing those tokens.

To make this less painful, we’ve added the ability to define Global Variables for things like API tokens or URL roots. These Global Variables can be re-used in multiple API Check tests.

global-variables

Learn more about Global Variables on Rigor’s Knowledge Base here: API Check Global Variables

Conclusions

Every one of these new feature enhancements for our API Check was made possible because Rigor users came to us with their use cases and helped us understand their needs. We’re excited to make these options available. And, we’ll continue to evolve what’s possible with API Checks so that we can accommodate user needs. It’s our goal to make it easier to fit API Checks into your continuous performance management workflows.

Do you have an application that’s dependent on a first-party or third-party API? Do you provide data to your customers via an API? Looking for transparency into the availability, functionality, and performance of an API? If yes, definitely give Rigor’s API Check a try and see how it can work for you. Start a Rigor trial or email support@rigor.com to add API Checks to your existing Rigor account today.

Suggested Blog Posts