News & updates from the Flare team
- Jump to
-
- Deep Dives
- News
Introducing: Dark mode for Flare
We heard you, so here it is: a Dark Mode for Flare!
Dries
Every exception has a backstory: introducing previous exceptions in Flare
Flare now shows previous exceptions. Navigate the whole chain and see the stack trace of the exception that actually caused the failure.
Ruben
Why we removed AI solutions from Flare
AI generated solutions are dead, long live AI generated solutions! We removed the old one-shot fixes from a model that could only see the stack trace. It simply couldn't compete with modern agentic AI. In their place, Flare works with the agentic AI tools you already use: an MCP server that handles real triage, a CLI with an agent skill, quick Copy for AI prompts in the UI and docs served as markdown. Hosted agents are in the works too.
Alex
Bringing Flare back to Laravel 10 and PHP 8.1
Flare now supports Laravel 10 and PHP 8.1 again, so older apps get performance monitoring and logs too. Here’s how we did it.
Ruben
One core, many clients: the new Flare JavaScript client architecture
We recently reshaped the Flare JavaScript client from a single browser library and a few thin framework specific packages into a small family of packages built on a shared, platform-agnostic core. This post explains why we did it, what the core package exposes, how the browser and Node SDKs are built on top of it, why the React, Vue, and Svelte packages sit one level higher, and how anyone can use the same core to write a Flare JS client for a platform we do not ship ourselves.
Dries
Flare ❤️ Livewire
Flare has deep Livewire visibility: components nested in traces with full hierarchy, per-phase timing (mount, hydrate, render, dehydrate), aggregated component views with bidirectional links, rich error context, and a lot more. Let us show you how Flare can assist in debugging your Livewire project.
Ruben
Integration testing our Laravel package with a real server and queue
When unit tests aren't enough. We started testing the Laravel Flare package against a real application in order to verify that our code works using orchestra workbench. Here's how we did it.
Ruben
A minimal "Last used" login option indicator with Alpine.js
Flare's login page now remembers which sign-in option you used last time. Built on Alpine's $persist plugin and just about 25 lines of code.
Alex
How Flare handles Livewire v4's single file components
Single file components are a great addition to Livewire v4, but their compiled output makes debugging harder. Here's how we taught Flare to map hashed file paths and line numbers back to your actual source files.
Ruben
Track frontend errors back to the exact commit
Swap the default random UUID for your git commit hash and trace every JavaScript error straight back to the deploy that caused it.
Dries
A unified error debug timeline
We've reworked the error debug timeline to show all events in chronological order and added support for HTTP requests, Redis commands, filesystem operations, and caching events.
Ruben
New and improved settings screens
Did someone say Spring Cleaning? We've redesigned the settings pages across Flare to be more consistent, intuitive, and pleasant to use.
Dries
How we accidentally dropped half our traces: a tale of Cloudflare Workers and WAF
Yesterday we found out that about half of the traces sent to Flare weren't making it through. After a few hours of debugging, the culprit turned out to be our own rate limits. A Cloudflare routing change caused our Worker's internal requests to pass through the WAF, where they got rate limited and dropped. Here's how we found and fixed it.
Ruben
Require two-factor authentication for your team
Team admins can now require all team members to enable two-factor authentication before accessing Flare.
Alex
Introducing Flare’s next big feature: performance monitoring
Flare's new Performance Monitoring feature is now live, giving you complete visibility into your Laravel app's HTTP routes, queued jobs, Artisan commands, and database queries.
Freek
Lessons from the deep end
20 months ago, we started building Performance Monitoring as Flare’s next big feature, never expecting Laravel’s rapid commercial growth to put us in direct competition with their own tools. This is our honest take on those 20 months went, how we’re adapting to this new reality, and where we’re heading next while staying true to who we are. A dive into the deep end, without knowing how far down it goes.
Alex
Using ClickHouse at Flare to aggregate data
We're building the next chapter of Flare with performance monitoring, in this first chapter we take a look at aggregating data with a new database called ClickHouse
Ruben
Automating styles with data-slot
In this post, we explore how the data-slot attribute, inspired by Adam Wathan’s Laracon US 2024 presentation, can streamline React component design. By dynamically adjusting styles based on the children within components, we eliminate the need for extra props and reduce complex conditional logic. Using Tailwind CSS, we show how a simple button component can automatically adapt its layout and appearance based on its content.
Sébastien
Building a micro dependency container, because why not?
When rewriting the Flare framework-agnostic PHP package we needed a dependency container, so we've created our own one!
Ruben
Perfecting Flare: one annoyance at a time
Over the next few months, we're committed to fixing bugs - not just in your code, but in our app too. We’ve got a bunch of improvements lined up to make Flare even better!
Alex
Using 1password for Laravel environment variables
Secret management isn't the most thrilling part of development, but it's crucial. Let's look at some options, why we chose the 1Password CLI and how to set it up.
Alex
When everything fails, you can always trust the Laravel rescue helper
Laravel's handy rescue helper to the ... rescue!
Ruben
Laravel's report helper: a must for error handling
For any application, handling errors gracefully is crucial for maintaining a smooth user experience. While PHP's try-catch statements are great at catching known exceptions and preventing them from crashing your application, they also make exceptions go unnoticed. What if you also want to log and report an exception without bringing your application to a screeching halt? That's where Laravel's report helper steps into the spotlight.
Alex
Handled exceptions
We now mark exceptions as handled when they don't crash your application.
Ruben
WeakMaps a hidden gem in PHP
In PHP 8.0 WeakMaps were added, a mystical feature we never used until we had a complicated issue to solve.
Ruben
Running Ignition on five years of Laravel
How to fix bugs for packages used by all versions of Laravel released in the past five years?
Ruben
Introducing Laravel Error Share
Share your errors to Flare from the new default Laravel error page.
Freek
Rethinking deploys at Flare
Flare has long relied on locally running Laravel Envoy for our app deployments. However, as the application and infrastructure evolves, so do the challenges. This article documents some of our endeavors to come up with a more robust solution in 2024 while keeping our deploys as simple as possible.
Alex
How we stopped a DDoS attack at Laracon
Laracon EU 2024 was an awesome conference, we were sponsoring with Flare and having a blast until a DDoS attack hit us.
Ruben
Migrating from MySQL to Postgres using Laravel's query builder
We've recently switched our database infrastructure from MySQL to Postgres, this is a high level overview on how we used Laravel's query builder to migrate our data.
Rias
Enhancing error reporting with custom context and glows
Using custom context and glows adds extra information to error reports, helping you quickly understand and fix problems in your Laravel applications.
Zuzana
How we built our GitLab integration
A few days ago, we added a GitLab integration. In this blog post, we'll talk about the road to that integration and our struggles.
Ruben
You can now give team members access to specific projects
We've improved user management on Flare.
Freek
Leveraging Cloudflare Workers for Edge API Authentication
Learn how Cloudflare Workers in Flare enable edge-based API authentication, effectively filtering out unauthorized requests and enhancing performance for your application.
Alex
Building a flexible yet abstract external integrations Structure
We created a new structure for external integrations like GitHub and Jira which allows us to add these kinds of integrations a lot quicker.
Ruben
Why error tracking is crucial for your application
Errors will inevitably occur in your application. There is no way around it. If you notice them while working locally, you can fix them immediately. However, if your application is already live, it gets more tricky because you are not the only person triggering errors anymore. This is where error tracking software like Flare comes in handy.
Christoph
New teams will now see an example project
This will make it easier for newcomers to get familiar with Flare
Freek
Unveiling error notes and the activity feed
Today we're introducing the error activity feed and notes.
Ruben
Web animation wizardry
Picture this: a bunch of developers, most of them back-enders, are given a Figma design file to turn into the new homepage for Flare. We set out to build our brand-new marketing site with a sprinkle of animations. Here is how we crafted them.
Sam
You can now log in using your Google or GitHub account
Here's how you can implement our log in flow in your Laravel app
Rias
Managing production environment variables for Laravel deployments
Secret secrets are no fun, secret secrets hurt someone... unless they're managed right in your Laravel deployment! Say goodbye to plaintext perils and .env file follies. For Flare we explored some alternative solutions like config servers, the env:encrypt command and git-secret to keep your production environment variables safe and sound. Using git-secret's with user-specific access control and PGP encryption, managing environment variables becomes a breeze.
Alex
Flare 2.0 has been launched!
These past months, we've been busy redesigning our entire service. We're very proud to launch it today.
Sebastian
Sensitive parameters in PHP 8.2
Debugging errors can leak sensitive information, let's see how we can solve this using PHP 8.2
Ruben
Caching Inertia's SSR responses
SSR Inertia and response cache: the ultimate performance and SEO combo!
Alex
Flare 2.0 is right around the corner
Good things are coming!
Spatie Team
Changing your larger-than-average MySQL table
We're still working on our redesign and are close to release. Today we started tackling an issue where the performance of the error page was too slow for us. In the end, we needed to change the structure of the error occurrences table, which is a lot harder than it seems.
Ruben
Fetching data to render complex graphs in Flare
The new version of Flare has a lot of graphs, but how do we calculate the data
Ruben
Optimizing Flare
We're redesigning Flare, but our application became really slow. Let's find out why and fix it!
Ruben
A preview of our upcoming redesign
We're giving our entire service a new coat of paint
Spatie Team
Fixing nested validation in Laravel
Since the early days, Laravel has had an excellent validator available, but sometimes it doesn't work as expected, especially with nested arrays.
Ruben
Subscribe to Backtrace, our quarterly Flare newsletter
No spam, just news & product updates