Code Execution Monitoring for Symfony applications using Inspector – Tutorial

Valerio Barbera
graphic for real-time code execution monitoring with Symfony and Inspector logos

Hi, I’m Valerio software engineer, founder and CTO at Inspector.

As a product owner, you may have experienced how an application issue can be hard to identify and fix. It can negatively impact the users’ experience or block new potential customers in their onboarding path.

Users don’t spend their time reporting bugs, they just stop using our application if it doesn’t work as expected, looking for another one that fits their needs better.

The idea behind Inspector is to create a monitoring environment specifically designed for software developers. Therefore, it avoids any server or infrastructure configuration that developers hate dealing with.

Thanks to Inspector, you will never have to install things on the server or make complex configurations at the infrastructure level.

It works with a lightweight software library that you can install in your application like any other dependencies. In case of Symfony you can use our official Symfony Bundle.

Developers are not always comfortable installing and configuring software at the server level. These installations are out of their software development lifecycle or are even managed by external teams.

Forcing teams with different goals (Developers, IT infrastructure, Cyber Security, etc.) to work with the same tools can cause confusion. And it can compromise developers’ ability to quickly identify and resolve app problems.

Inspector allows developers to have a code-driven monitoring environment entirely under their control. So they will be the first to know if the application is in trouble. Moreover, it does so “before” users stumble onto the problem.

This functionality drastically reduces negative impacts on the user’s experience. It gives you the proper foundation to run a successful user acquisition process and continually increase engagement with your product. And all with the fewest interruptions possible.

Symfony Code Execution Monitoring: how it works

Inspector is a Symfony bundle to add real-time code execution monitoring to your application, allowing you to work on continuous code changes while catching bugs and bottlenecks in real-time before users do.

It takes less than one minute to get started. Let’s see how it works.

Install the Symfony bundle

Run the composer command below in your terminal to get the latest version:

composer require inspector-apm/inspector-symfony

Configure the Ingestion Key

Get a new Ingestion key by signing up for Inspector (https://app.inspector.dev/register) and creating a new project, it takes a few seconds.

You’ll see installation instructions directly in the app screen:

Create the inspector.yaml configuration file in your config/packages directory, and put the ingestion_key field inside:

inspector:
    ingestion_key: [your-ingestion-key]

Test everything is working

Execute the inspector:test command to check if your app sends data to Inspector correctly:

php bin/console inspector:test

Go to https://app.inspector.dev/home to explore the demo data.

By default, Inspector traces:

  • Database interactions
  • Console commands
  • Twig view redering
  • Controllers operations
  • Unhandled Exceptions

Explore your application’s performance metrics

When your application receives a request, Inspector automatically detects the most important events executed to fulfill the request. Then, it creates a visual representation of what happens inside your code during its regular operation.

Transactions stream in your dashboard in real-time, and for each transaction, you can monitor what your application is doing:

Add custom segments to the timeline

Inspector monitors database queries, HTTP requests, and console commands by default. Still, there might be critical statements in your code that you need to monitor for performance and errors. Such as:

  • Http calls to external services
  • Function that deals with files (pdf, excel, images)
  • Data Import/Export processes

Thanks to Inspector, you can add custom segments in your timeline besides those detected by default. This functionality allows you to monitor a custom code block’s impact on application performance.

Let’s look at a real-life example.

Suppose you have an HTTP route that executes some database operations and performs an HTTP call to an external service.

Inspector automatically detects database queries. But, it would be interesting to see the external HTTP request in the timeline to monitor its execution over time and activate alerts if something goes wrong.

class BlogController extends AbstractController
{
    /**
     * @Route("/posts/{slug}", methods="GET", name="blog_post")
     */
    public function postShow(Post $post): Response
    {
        $tags = this->externalService->get('tags');
        return $this->render('blog/post_show.html.twig', compact('post', 'tags'));
    }
}

You can wrap the external service call with a segment to add it to the transaction’s timeline. Type hint the Inspector service into the controller method to access the Inspector instance:

use Inspector\Inspector;
class BlogController extends AbstractController
{
    /**
     * @Route("/posts/{slug}", methods="GET", name="blog_post")
     */
    public function postShow(Post $post, Inspector $inspector): Response
    {
        $tags = $inspector->addSegment(function () {
            return this->externalService->get('tags'); // return value will be transparently returned back.
        }, 'http');
        return $this->render('blog/post_show.html.twig', compact('post', 'tags'));
    }
}

Errors & Exceptions Alerting

Every unhandled exception fired in your Symfony app is automatically reported by default. These reports alert you to unpredictable errors in real-time.

We all wish that every change to our code could be perfect. But the reality is that this is not always the case. Some errors appear immediately after an update, while others pop up at random. It’s a fact of life for developers. Many errors often depend on connection issues between your application and other services.

But, Inspector makes the job easier. It automates the detection of unknown issues. You no longer need to manually check the status of your apps or await reports from users. If something does go wrong, you’ll receive a notification in real-time. And after each release, you stay informed about the impact of the latest code changes.

If your code fires an exception, but you don’t want to block the execution, you can report the error to Inspector for personal monitoring:

try {
    // Your dangerous external call here...
} catch (GuzzleException $exception) {
    $inspector->reportException($exception)
}

Conclusion

When a customer reports that something isn’t working, it forces you to drop whatever you are doing and try to reproduce the scenario. You then have to recapture and reanalyze the logs in your toolset.

Getting an accurate picture of what’s happening in your code can require hours or even days. Inspector makes a massive difference in your efficiency, productivity, and customer happiness because it allows you to avoid this scenario.

Try Inspector for free and as long as you want

To let everyone interested try this new solution, Inspector offers a free tier with up to 30,000 monthly transactions. And it’s not a limited trial. So, you and your team can get familiar with Inspector without the pressure of a deadline.

Create your account

I hope you will try and enjoy the Inspector experience.

If you found this article helpful please share it with others who could benefit from using a monitoring tool like Inspector.

Join the “Scalable Applications” community

If you want to learn more about scaling up your application, join Scalable Applications. It’s an international community of professional developers sharing strategies and experiences for building scalable systems.

Join us now

Related Posts

Logging Database Queries with Eloquent ORM and Laravel – Fast Tips

Having a more clear understanding of what your application really does during its execution is an increasing necessity. Logging the raw database queries generated by your preferred ORM is one of the most common needs to be more aware of what is happening behind the scenes. More and more abstraction layers are becoming available in

Laravel Http Client Overview and Monitoring

Laravel HTTP client was introduced starting from version 10 of the framework, and then also made available in all previous versions. It stands out as a powerful tool for making HTTP requests and handling responses from external services. This article will delve into the technical foundations of the Laravel HTTP client, its motivations, and how

Laravel Form Request and Data Validation Tutorial

In this article I will talk about Laravel Form Request to send data from your application frontend to the backend. In web applications, data is usually sent via HTML forms: the data entered by the user into the browser is sent to the server and stored in the database eventually. Laravel makes it extremely simple