This article will explain how you can approach application performance monitoring in the development stage of your application's life cycle.
As the name suggests, an application is being actively developed in the developing stage. Regardless of what methodology is used here (Agile, Waterfall, etc.), this phase aims to build a launch-ready product.
Defining quality from day zero is essential to help achieve this goal.
In the development stage, features may be getting shipped at a lightning pace, but code quality should still be maintained. At the beginning of a product's life cycle, it's important to consider and have a consensus on what defines the quality of your product.
You can achieve quality from day zero through a broad range of practices such as:
|Test Driven Development (TDD)||Writing unit tests before writing code to ensure the code's logic meets the desired requirements.|
|Manual testing||Manually testing the application to ensure it behaves as expected and achieves the desired results.|
|Code reviews||Requiring an approved code review to merge a pull request.|
|Continuous Integration (CI)||Frequently committing code changes and running automated tests per commit, only allowing code with passing tests to be merged into an application's main branch. Allowing issues to be caught early and limiting integration problems.|
|Quality metrics tracking||Tracking key metrics that help indicate and measure the quality of an application's code base, from code coverage to error tracking.|
You can ensure quality by requiring all code to be reviewed, tested (automatically and manually), and to pass all CI checks (such as linting) before being merged into the main branch and deployed.
Once you've defined what quality is, you need to consider the following:
It's important to test your application in both the localhost and staging environments before merging it to production. In this way, any issues or bugs can be resolved and you can prevent them from impacting end users.
On localhost, you can test your application in a controlled environment, which can be configured to meet the exact needs of the feature you are working on. You are able to zoom in and focus on specific functionality without having to also take into account the broader impact on your application. You can ensure your application functions as expected through testing and catch visible, critical errors.
On staging, you can test in an environment that should more closely resemble production, with scheduled background jobs and the same stack of technologies your production application will use. You can see how your code runs in "real-world" conditions and test for unexpected issues that might impact end users.
With AppSignal, you can monitor multiple environments for your application and gain insights that manual and automated testing alone cannot. These insights allow you to quickly identify environment-specific issues (such as using the wrong API key) that might have been missed otherwise. You'll be more likely to spot significant problems before they become problematic on production.
Even if you run automated testing, manual testing, and continuous integration tests, your application will still encounter errors. Some of these errors may be visible - for example, an exception that's raised when trying to add an item to a shopping cart - and others may be invisible, such as an error in a background job.
With AppSignal's error tracking, exceptions can be automatically tracked and reported. This allows you to continue developing and testing your application knowing that AppSignal will notify you should an exception occur. AppSignal will share critical data about each error, such as the error message, host information, and samples of every previous occurrence of that error, so you can inspect and compare issues to inform you of the best possible fix.
By monitoring how your application responds to queries, you can ensure that it is able to handle higher demand post-launch.
AppSignal tracks the performance of requests and helps you understand which requests are slow. You'll be presented with a breakdown of your requests' actions and how long they take to execute, helping you identify which request actions need optimizing before launch.
For example, in the above screenshot, we can see that our MongoDB query takes up most of our request time and is likely underperforming. Rather than spending hours troubleshooting our application, we can immediately tackle our database query to decrease the application's response time.
Effective collaboration and communication are critical for success. AppSignal can be integrated into various popular collaboration tools like GitHub, Jira, and Slack. Once integrated, you can report errors directly from AppSignal to your project's issue tracker, eliminating the need for manual error reporting and reducing the risk of errors being accidentally overlooked.
This article is part of a series. We have a Learning Center article for each stage in the product life cycle:
Join us with a free trial to start monitoring your application with AppSignal. You can be set up in as little as five minutes. If you have any questions or require help, our dev-to-dev support is on hand.
Do you need help, have a feature request or just need someone to rubber duck with? Get in touch with one of our engineers.