Improved Search and Filtering

We’re happy to announce that we’ve launched a brand new way to filter your errors. We’ve streamlined our filtering options to make it easier than ever to find the errors you’re looking for.

Unified Interface

We’ve unified search and filtering into one easy-to-use search box. You can now switch between “Resolved” and “Unresolved” errors, search, and filter all in one place.

Search Input


Start typing in the search box and see your results update in real-time. The default search box at the top of your error groups list supports text searches for:

  • Error type
  • Error message
  • Filename
  • Environment

Advanced Filtering


In addition to that, you can select advanced filter options to further narrow your results. These options are shown as suggestions beneath the search input and will autocomplete as you type.

  • Environment: e.g. Production, Staging, QA, etc.
  • Component: The controller the error occurred in
  • Action: The controller method the error occurred in
  • Deploy: Set up using Deployment Tracking
  • Before: Shows all groups with last occurrence before a specific date
  • After: Shows all groups with last occurrence after a specific date
  • On: Shows all groups with last occurrence on a specific date

As always, we would love to hear your feedback about this feature and any other features that you’d like to see in Airbrake. We have many more search improvements in the pipeline, so stay tuned for future updates!

New to Airbrake? Start your 30-day free trial today and you’ll be organizing and tracking all your application’s errors in just a few minutes.

Bugs In Your Code: How Much Are They Really Costing You?

Bugs in your code might be hurting more than just the quality of your software. We dug up this infographic from SourceNinja that outlines the financial pitfalls of bugs in code – especially open source code. The findings are eye-opening!

If you’re using any open source code in your project, you’ll want to take a look at this, and consider taking a look at an error monitoring tool like Airbrake. It could save you a ton of time, money and grief.

No credit card required.

bugs in your code

Key Findings:

  • 9 out of 10 companies use open source projects.
  • 4 out of 10 companies experience problems because of third party code.
  • Only 35% of third party code is tested for bugs. Compare that to 70% of internally developed software.
  • Defective software costs $60 billion annually.
  • In 2010, Coverity released an analysis of the Android kernel (a very high quality open source project). They found
    • 57 control flow issues
    • 36 error handling issues
    • 17 incorrect expressions
    • 53 incidences of insecure data handling
    • 23 issues with integer handling
    • 83 null pointer dereferences

No credit card required.

You can’t afford to have buggy open source code powering your app, but the fact of the matter is you probably do 🙁 This is exactly why Airbrake’s error monitoring tool exists. You’ll be notified of all the bugs holding your code back, and be able to trace them right back to the source.

In addition to employing some kind of error reporting or monitoring tool, we recommend keeping close tabs on software updates! Open-source libraries are often maintained quite well, and keeping your code up to date could mean the difference between crippling bugs in your code and a clean, secure application. When updates for a library are dwindling, it may be time to consider moving on to a different solution.

Are there bugs in your code from open source software? Can you afford to inherit those bugs? Even if you think you can…is that how you want to maintain your application? Whether you use Airbrake or not, we highly recommend you take the time to think about these questions and come up with a plan to maintain clean and secure code.

No credit card required.

PHP Exception Handling: UnexpectedValueException

PHP Exception Handling: UnexpectedValueException

Today we’ll look at UnexpectedValueException – the runtime-only version of  UnexpectedValueException. Read on to see how to add this to your PHP exception handling repertoire!

The Technical Rundown:

  • All SPL exceptions extend either LogicException or RuntimeException. UnexpectedValueException extends RuntimeException.
  • UnexpectedValueException is thrown if a value does not match with a set of values.

When Should You Use it?

To learn more about UnexpectedValueException, we’re going to make a salad using the makeSalad() function below.

How do you make a salad? You get the ingredients and you combine them (I know it’s not always this simple but…this works as an example, so…). The functions in our makeSalad() function appear to do just that. Perfect!

But what if there are no ingredients left? You can’t exactly make a salad – or anything for that matter – without ingredients. If we try to makeSalad() without ingredients, we’re going to end up with a literal nothing salad. This is a handy time to use UnexpectedValueException!

Now, when we attempt to makeSalad(), but have no ingredients, we’ll be notified that we need more ingredients, and it’s time to go shopping! This way, we don’t waste our time, or our customers time, making a nothing salad.

Crisis averted! UnexpectedValueException is the best way to deal with potential gaps in functions, and prevent wasted time spent using values that aren’t going to work. Yet another tip for you to use on your quest for php exception handling perfection. To take it a step further, check out Airbrake’s PHP bug tracker!

PHP Exception Handling: UnexpectedValueException

PHP Exception Handling: Exception Class Hierarchy

PHP’s built in exception classes makes PHP exception handling simple! PHP exceptions are broken down into a hierarchy, with LogicException and RuntimeException serving as the parent classes. Both LogicException and RuntimeException extend the Exception class. Here’s a look at the entire PHP Exception class hierarchy.

  • Exception
    • LogicException
      • BadFunctionCallException
        • BadMethodCallException
      • DomainException
      • InvalidArgumentException
      • LengthException
      • OutOfRangeException
    • RuntimeException

LogicException refers to to any error that occurs due to faulty programmatic logic. For example, if an argument of an undesired data type is passed, a LogicException should be thrown. Here are quick descriptions of its child classes.

  • BadFunctionCallException – Exception thrown if a callback refers to an undefined function or there are missing arguments.
  • BadMethodCallException – Extends BadFunctionCallException. Exception thrown if a callback refers to an undefined method or there are missing arguments.
  • DomainException – Exception thrown if a value doesn’t match a defined valid data domain.
  • InvalidArgumentException – Exception thrown if an argument differs from expected type.
  • LengthException – Exception thrown if a length is invalid.
  • OutOfRangeException – Exception thrown when an illegal index was requested. This represents errors that should be detected at compile time.

RuntimeException refers to any error which can only occur on runtime. For example, if a function outputs an unacceptable value, a RuntimeException should be thrown. Here are its child classes:

  • OutOfBoundsException – Exception thrown if a value is not a valid key.
  • OverflowException – Exception thrown when adding an element to a full container.
  • RangeException – Exception thrown to indicate range errors during program execution. The runtime version of DomainException.
  • UnderflowException – Exception thrown when performing an invalid operation on an empty container.
  • UnexpectedValueException – Exception thrown if a value does not match with a set of values.

These built-in exception classes are helpful PHP exception handling tools! Used with Airbrake’s PHP exception tracker your debugging process will be a breeze! Good luck!

PHP Exception Handling: UnexpectedValueException

PHP Exception Handling: InvalidArgumentException

Today in the PHP Exception Handling series, we’ll take a look at one of PHP’s built in exception classes. Specifically, we’re looking at InvalidArgumentException, what it means, and when it’s most useful! Built in exceptions like this one help make PHP exception handling a breeze! Let’s get to it…

The Technical Rundown:

  • All SPL exceptions extend either LogicException or RuntimeException. InvalidArgumentException extends LogicException.
  • InvalidArgumentException is thrown when the provided argument is not of the expected type. (sounds about right)

When Should You Use it?

The InvalidArgumentException is optimal for…well…validating arguments. To learn when this might be useful, take a look the function below – doubleInt().

Simple enough! Pass doubleInt() an integer, and it will return that integer multiplied by two. So, if we run doubleInt(3) like on line 8 above, our output will be the integer 6.

But what happens if we do something like this?

Unfortunately, as you know, this would not output two kittens, (Don’t worry, I’m nearly done with my doubleKitten() function). The string “kitten” doesn’t multiply nicely in PHP, so what we end up with is an output of 0.

Not only is this output totally not useful, but we aren’t notified that anything has gone wrong. PHP simply gives us the output of zero and moves along. Here’s where InvalidArgumentException comes in.

Now that we’ve got a check built in to see if $int is, in fact, an integer, we’re in business. If $int is not an integer, InvalidArgumentException will throw us the error message we determine as part of the exception. In the case of the “kitten” argument:

Fatal error: Uncaught exception 'InvalidArgumentException' with message 'doubleInt expects an integer. Input was: kitten - not an integer.'

With this exception, we’ve now been informed that something happened that wasn’t quite right. In the case of of user input, this is useful because we can now suggest the user submit the correct data type.

And that’s it! InvalidArgumentException is a simple and elegant way to catch arguments of an incorrect data type. On its own, InvalidArgumentException is useful on small projects, but for larger projects you might consider Airbrake’s PHP bug tracker!

Spiral Model: Software Development For Critical Projects

The Spiral Model – first described by Barry Boehm in 1986 – is a software development methodology that aids in choosing the optimal process model for a given project. It combines aspects of the incremental build model, waterfall model and prototyping model, but is distinguished by a set of six invariant characteristics.

Spiral Model

The original spiral model diagram. Credit – Barry Boehm, & Wilfred J. Hansen

The Spiral Model is concerned primarily with risk awareness and management. The risk-driven approach of the spiral model ensures your team is highly flexible in its approach, but also highly aware of and prepared for the challenges they can expect to face down the road. The spiral model shines when stakes are highest and major setbacks are not an option.

1. Define Artifacts Concurrently (AKA “Plan everything, then re-plan those plans, then plan some more.”)

In programming, an ‘artifact’ is any thing produced by people involved in the software development process. The spiral model suggests that all artifacts in a given project lifecycle should be defined fully from the start.

By planning each and every artifact of a project, your team reduces the potential for technical debt and other mishaps. For example, what if your software is reliant on an unusual, expensive or nearly obsolete piece of hardware? Or worse, what if after months of work you realize what you’ve been striving to build cannot actually be achieved? These types of issues can be disastrous.

Defining the scope of your entire project ensures you make the most of your time, and avoid potentially catastrophic scenarios.

2. Four Essential Spiral Tasks

According to Boehm, every spiral model cycle consists of the following four tasks.

  1. Consider critical-stakeholder objectives and constraints.
  2. Elaborate and evaluate alternatives for achieving your objectives.
  3. Identify and resolve risks attendant on choices of alternative solutions.
  4. Stakeholders’ review and agree to proceed based on satisfaction of their critical objectives and constraints.

The second characteristic of the Spiral Model – just like the first – is primarily concerned with mitigating risk and reducing the potential for setbacks. In this case, focusing on the wishes of critical stakeholders rises to the forefront. By performing these four activities, your team ensures it won’t pursue options that don’t satisfy the core needs of the project or present a high potential for risk.

3. Risk determines level of effort

Invariant three suggests that the effort allocated to a component of your project should be determined by the severity of risk associated with that component. Take the following chart for example:

Spiral Model Management

We can see that after a certain point, the risk of losing market share far outweighs the gains made in testing. Yes, testing is important, and reduces the likelihood of releasing a buggy product, but speed in software development, speed is just as important (if not more important). Don’t let your aversion to one risk hinder your ability to account for another.

4. Risk determines degree of details

Invariant four says the potential for risk should determine how much attention you pay to the details of the project you’re working on.

Let’s say you’re introducing a new suite of features to your application. Seems like a no-brainer, right? More features = happier customers. Well…is that always the case? What if your existing customers become overwhelmed by a new interface, or miss the way your product behaved in the previous version? This situation could be pretty bad – you might have some people jumping ship. It would have been best to gather more data and implemented your changes more carefully.

On the other hand, let’s say it’s time to spruce up the language on your site to communicate your offering more clearly. Is this a critical component of your success? Yes. Is getting it wrong going to ruin you? Probably not. In this case, it’s probably safe to throw a few different things up on your site, test them and see what sticks! Don’t sweat the small stuff.

5. Use the anchor point milestones

The spiral model consists of three “Anchor Point Milestones.” They are:

  • Life Cycle Objectives (LCO)
  • Life Cycle Architecture (LCA)
  • Initial Operational Capability (IOC)

These milestones serve as intermediate checkpoints to keep the project moving full steam ahead in the right direction.

The LCO milestone checks to see if the technical approach to a project is well-defined enough to proceed, and that stakeholder conditions are met. If “Yes”, continue. If no, abandon ship or commit to another lifecycle and try again.

The LCA milestone checks that an optimal approach has been defined and that all major risks are accounted for and planned for. If “Yes”, continue. If no, abandon ship or commit to another lifecycle and try again.

The ICO milestone checks that adequate preparations have been made to satisfy stakeholders prior to launch. This includes the software, site, users, operators, and maintainers. If “Yes”, its time for launch! If no, abandon ship or commit to another lifecycle and try again.

6. Focus on the system and its life cycle (Or “Software Isn’t Everything”)

Yes, the Spiral Model is a software development process, but that doesn’t mean you can ignore non-software aspects of your business, or that every problem can be solved with a bit of code.

If you’re experiencing troubles converting leads, that doesn’t mean you need to build a sophisticated sales robot. Maybe it’s just time to re-visit your sales tactics! More software is not always better, and you may find that throwing software at non-software problems only complicates them more. Focus on the underlying goals of the project and see to it that the solution you employ is the one best suited for meeting your win conditions.

So…what now?

While the Spiral Model can be a bit odd to define, one thing is for sure – it’s a great way to keep your eyes on the prize and minimize the risk you assume when building something new. The invariants are great to keep in mind, but we’ve only just scratched the surface of this interesting software development life cycle tool. Check out Boehm & Hansen’s official write-up below to learn even more about Spiral Model.

Spiral Development: Experience, Principles & Refinements – Boehm & Hansen

Airbrake dashboard: visual refresh

At Airbrake, we constantly strive to improve our product to offer the very best. Today, we’ve refreshed the dashboard, improving how you view and navigate errors.


It was obvious that our old dashboard felt dated and needed a retouch. We didn’t want to throw everything at once, so you could have more time to adjust to the changes. First preparatory step that we’ve made prior to launching the new look was using system fonts instead of our custom one. This change made the dashboard much faster to load, and improved mobile users experience. Next, we’ve made some visual changes to the look of our buttons, so they are now unified with the rest of Airbrake. Finally, we are ready to publish the biggest change, which touches almost every aspect of the dashboard. Let me briefly guide you through the changes.

Reduced number of tabs


After we added Aggregations, we felt the tab view had become a little cluttered. We’ve fixed this by moving Backtrace, Params & Context into the Occurrences tab. This greatly improves the mobile experience; users no longer need to scroll horizontally to be able to access the tab they want. Four tabs fit on all modern mobile screens.

Redesigned Occurrences tab

Previously, the occurrences tab was a simple table showing all occurrences in the same error group. Now, it has drastically changed. First of all, the table was moved to another view accessible via the “View Occurrence List” link. Next, global notices pager was moved under the Occurrences tab. The tab itself displays more granular data such as brief error details, backtrace, context & parameters. Similar functionality was available in the previous design, but it was hard to observe differences between each notice because you needed to go to a separate tab every time. Now, everything you need is in the same view.


The table was also improved. Every entry has additional columns such as “hostname” and “remote address”. Additionally, you can open an occurrence by clicking on the entry ID. Finding the table pager is easier now as well, since we moved it from the bottom to the top.


Linkable tabs


The tabs are now linkable. It means that you no longer have to explain to your colleagues which tab you need to click to read certain piece of information. Just link straight to the tab you want.

Sortable aggregation tables


Previously, aggregation tables were sortable only in one direction. Now, you can sort them in both directions (ascending & descending).

Scalable graphs

All Airbrake graphs are now scalable. Previously, if you resized your browser, you needed to fully refresh the dashboard to redraw the graphs. Now, the graphs will adjust automatically to the width of your browser window.

Responsive design improvements

Apart from graphs, we’ve made many other minor tweaks to improve responsiveness of our dashboard for both, desktop and mobile users. Our dashboard can be used on every modern device that you have.

We’re excited to ship this retouch and we would love to hear your feedback. Contact us via our email to let us know what you think about it.

Airbrake Docs Relaunch

This summer we relaunched and refreshed the Airbrake docs. The docs were moved in-house, open-sourced on GitHub, given a style overhaul, and are now available at We hope the new docs provide you with a cohesive and enjoyable experience, helping you become an expert Airbraker one doc at a time.

The docs are home to a wealth of Airbrake information including:

Document updates

We used the relaunch as an opportunity to vet each doc, keeping our eyes open for chances to improve readability, update screenshots/images, and make sure content is organized into logical sections.

Builds and deploys

We automatically build and deploy airbrake-docs as a static site to our CDN. This strategy is low cost and reduces the possible problems related to managing airbrake-docs. There are no server processes to keep running and the docs are distributed globally.


Providing feedback on docs has never been easier. You can provide public feedback via GitHub issues, submit a pull request, provide private feedback anonymously via Temper, or just email us.

Thanks CircleCI

The Airbrake docs are based on the open-source circleci-docs project on GitHub.
CircleCI provides with free testing, building, and deployments for public repositories. Since airbrake-docs is a public repository, we use CircleCI to build and deploy the docs.

Just launched: Airbrake’s new & improved activity feed

We see it in our data, change happens really fast in software projects. Our projects are alive with code changes, deploys, and let’s not pretend…errors!

Some of our eagle-eyed users will have noticed we already had an activity feed, but we knew we could do better.

Today we have launched an overhaul of our project activity feed feature. With a fresh look, a promotion to the error dashboard, and new functionality to help you keep delivering quality, production software!

The new Airbrake activity feed

Deploy Tracking

If you are not tracking deploys with Airbrake, I encourage you to set this up. This is a really powerful feature which gives great insight into the relationship between your deploys and your errors.

The new activity feed takes this a step further, showing teams what changes were deployed, and when. Including errors each deploy was responsible for resolving. Projects that use a code management integration such as GitHub, Bitbucket or GitLab get links to code diffs, showing exactly what changes were deployed. We’ve found this feature particularly useful while trialling it internally, at Airbrake.

We hope you find this to be another useful tool in your quests to deliver quality software! We welcome any feedback and suggestions you may have. Without giving too much away, we have more exciting improvements for Airbrake in the pipeline.

New to Airbrake? Start your 30-day free trial today and you’ll be organising and tracking all your application’s errors in just a few minutes.