The latest ideas from TrackJS

After 12 years, TrackJS gets a modern UI refresh. Same reliable error tracking you know and love, just with a fresh look that doesn't move the cheese. Dark mode included!

Next.js caching is complex and more than a bit magical. This complexity is a source silent errors in the form of stale and incorrect data.

Error handling in NextJS doesn't have to be complex. TrackJS handles all the places where NextJS can fail

Did JavaScript break my store? Monitor errors in your Shopify store with TrackJS make sure your store keeps running great.

We are unlikely to add additional language support to TrackJS. And it's not just because of our name!

Learn from our mistakes: be careful when using VC funded companies as vendors or important parts of your stack.

Compare the strengths and weaknesses for Frontend Error Monitoring tools. We'll look at the focus, features, and pricing of the top contenders so you can pick the platform the works best for you.

Unprofitable companies, like Flexport and Splunk, are a risk for their customers because they can radically change or close down entirely. What about TrackJS?

TrackJS now offers Saved Filter Notifications - create custom alerts for specific error scenarios. Filter by message, user, URL, or other criteria, then get notified when those errors spike. Perfect for monitoring critical issues, API problems, or VIP user experiences.

Ad blockers are blocking TrackJS domains, causing you to miss JavaScript errors from 25-50% of users. Our new domain forwarding feature lets you use a custom domain (like errors.yoursite.com) to bypass ad blockers and capture all your error data.

TrackJS now supports Web Workers! Monitor errors in your background tasks including globally thrown errors, unhandled promise rejections, network failures, and more. Get full telemetry and visibility into worker threads to debug faster.

15 hard-won lessons from 15 years building web apps: write as little JavaScript as possible, use progressive enhancement, monitor everything, and keep it simple. Most valuable apps are under 10,000 lines of code - complexity kills maintainability.

TrackJS now officially supports Node.js! Monitor server-side errors with isolated request telemetry, automatic environment dependency discovery, and native integrations for Express and NextJS. Open source agent tracks errors across multiple concurrent requests.

TrackJS shipped key updates in May 2020: error comments for better bug communication, extended 60-day trials during COVID-19 disruptions, and progress on their new Request Metrics performance monitoring service. Team focused on polishing JavaScript error tracking.

We recently needed to parse and modify some query strings while building Request Metrics. Query string parsing has never been pleasant in .NET, has it improved in .NET Core? We were familiar with HttpUtility.ParseQueryString() for the task, but that API has a major landmine.

These are strange and interesting times. Our best wishes to all the developers and communities around the world affected by the COVID-19 epidemic. We're very fortunate at TrackJS to be a 100% remote company. Our team has been practicing social distancing for years!

We've been working on something big. We're building Request Metrics, a new service for web performance monitoring. TrackJS is a fantastic tool to understand web page errors, but what if your pages aren't broken, just slow? What if the checkout page takes 10 seconds to load?

TrackJS delivered January 2020 updates including a redesigned website that's faster, simpler, and friendlier, plus new page sharing functionality that lets teams share exact error pages and filters using the Share icon in the filter bar for better collaboration.

TrackJS unveiled a fresh new look for 2020 - cleaner, simpler, and more friendly. The redesign emphasizes their core strength: being the easiest way to understand and fix JavaScript bugs without enterprise complexity or jargon. Service-first approach meets modern design.

TrackJS closed 2019 with major updates: automatic URL grouping for UUID/numeric IDs to reduce noise, redesigned ignore rules builder for better error filtering, enhanced application management UI, and improved global filtering with stack trace and IP address support.

Ignoring noisy and external errors is important to understanding the health of your client-side applications. Third-party scripts, user extensions, content crawlers, and non-impactful errors create lots of noise in web operations. With TrackJS Ignore Rules, you can filter out this noise.

TrackJS shipped October 2019 updates including better formatting for long error messages with stack traces, new search capabilities on raw ungrouped messages, and major Elasticsearch reindexing improvements for faster performance.

Do you work with an app that's a dumpster-fire of errors? Wishing for an appropriate alert when you need to fight down the flames? Look no further friend. Today, we're creating a Dumpster fire notification for your JavaScript errors with Particle and TrackJS.

Today, we're releasing TrackJS Global Error Statistics to the public. This aggregated production data is a useful measure of the state of client-side JavaScript errors and the quality of the web. We break it down by the most common errors, browsers, and operating systems.

TrackJS shipped September 2019 updates including faster UI performance through Elasticsearch optimizations, new weekly site quality email reports, error read/unread tracking, and improved metadata filtering with logical AND operations.

It's remarkable to me how many developers have no idea what their time is worth. I speak with a lot of developers, and when I mention my work on TrackJS, I frequently hear "I could build that". Yeah, you could. Observability tools aren't rocket science. But you shouldn't.

We store all of our JavaScript error data in a large Elasticsearch cluster. This lets our customers slice and dice their error data in realtime, and perform full text searches over it. We push Elasticsearch to its limit, and we recently started querying more data for some of our core pages.

TrackJS gives your team visibility into how websites behave in production and the tools to understand bugs quickly. You can track your error rate over time and measure your progress. But how does your site quality compared to everyone else? Announcing a new kind of notification from TrackJS.

TrackJS shipped August 2019 updates including Microsoft Teams integration for notifications and enhanced Telemetry Timeline showing button text content for visitor clicks to improve UI interaction tracking.

Web sites continue to bloat with oversized images, custom fonts, and too much JavaScript. The huge amount of poor performing JavaScript on many sites drags desktop browsers and crushes low-end mobile devices. No one wants to work on sites like that. Here are three tips to reduce your JavaScript l...

Wrapping JavaScript functions lets you add common logic to functions you do not control, like native and external functions. Many JavaScript libraries, like the TrackJS agents, need to wrap external functions to do their work. Adding wrappers allows us to listen for Telemetry, errors, and logs in...

TrackJS shipped July 2019 updates including redesigned grouping pages with CSV export, beta NodeJS agent for server-side error tracking, and new platform/entry filtering capabilities with Node.js support.

The web is full of ads, and many users install ad blocker extensions to deal with them. But ad blocker extensions can break websites in strange and unintended ways, which often show up as errors in TrackJS. Ad blocker-related errors are common across our customers. So after debugging a few ad bl...

Your monitoring, instrumentation, and observability systems should be separated from your primary system infrastructure for resiliency and visibility. You already know monitoring is important, but you should also consider where you host your monitoring, to understand real user experience and reco...

A fictional story about software development. Sarah pulled up her LogCorp dashboard to start debugging. Customers were having sporadic issues checking out from the Acme site, but no one knew why. “This logging tool is so complex” she thought, “I have to re-learn this stupid query language every ...

TrackJS shipped June 2019 updates including RemoteJS for remote browser debugging with command sending and screenshots, plus redesigned Recent and Search pages with new UI styling and user-impact histograms.

The most frustrating bug I ever fought only showed up on a remote device. I was working on an AngularJS component, and for some irritatingly-unknown reason, it would not render on a Samsung Android device. One specific device. It just happened to belong to someone really important. Debugging rem...

We understand the value of JavaScript error monitoring here at TrackJS. Consequently, we run TrackJS on all of our own web properties to log our JS errors. We’re dilligent about fixing errors as they happen, and most issues are caught in development environments, or immediately in production. Ho...

The TrackJS team is hard at work streamlining the system and giving you even better tools to capture, understand, and fix the errors on the web. Here’s what we’ve been up to lately:

The web has a lot of background radiation: known errors, unsupported browsers, unstable networks, and misbehaving plugins all create noise. How do you sift through this noise to know when your JavaScript is melting down and creating real issues for your users?

We recently released a significant update to the way users filter and explore their error data. I want to discuss how we built it, the tools we used, and how we’re doing things “differently” than everyone else.

TrackJS shipped April 2019 updates including advanced error filtering with upgraded FilterBar, flexible metadata query syntax, improved source map handling with better error transparency, and user account deletion capability.

Dealing with noise is the biggest problem in client-side error monitoring.

Last week, I wrote “Adding Search to Your Site With JavaScript” over on David Walsh’s blog. It covered the basics of how we added search to the TrackJS Docs Site with client-side JavaScript and how to serialize out the page data with Jekyll. But our JavaScript search can do so much more! Let’s c...

TrackJS shipped February 2019 updates including 1Password data privacy fix, capture service response changes to remove Firefox console warnings, and Symbol type serialization support in the Agent.

TrackJS shipped January 2019 updates including isomorphic application support for the Agent, published new Security Policy documentation, and fixed status bug handling for very large accounts.

TrackJS shipped December 2018 updates including a minor XSS security fix, soft-launched new documentation site with improved layout and search, and added job monitoring for async error status operations.

Unless you were hiding under a rock, you probably heard about the “event-stream situation” on NPM this week. TLDR: the original maintainer of the event-stream package was tired of maintaining it. He handed over the reins to a different developer, who promptly injected malware and released a new ...

TrackJS shipped November 2018 updates including new Application Versions menu with histograms, Agent v3 as JavaScript module, Filter-Bar UI improvements, clearer billing error messages, and JSX syntax support in source code.

We recently released a new version of the TrackJS agent as a JavaScript module. This change was often-requested and long-overdue. It will make it way easier for you to include TrackJS in your applications and bundle it with your assets.

These days it’s common to release new versions of a web application daily, or even multiple times a day. At any given time there could be multiple versions of a code base running live in production. A new version might be getting soak tested on a pilot server, while the previous stable version ...

TrackJS shipped October 2018 updates including migration to MailGun for more reliable transactional emails, new invoice email design with branding updates, internal operations move to Slack, and navigation changes.

{Track:js} is gone. The name is anyway. We’ve removed the last vestiges of it, and we are now TrackJS. Hello! The name change has been part of a larger rebranding effort we’ve been working on to upgrade and elevate ourselves. An update to grow up from our scrappy roots and reflect the company we...

At TrackJS we pride ourselves on our pragmatic approach to software development. We’re cautious of making changes - every change must be weighed not only by its reward, but also its risk. We prefer to avoid big sweeping changes if possible. Smaller, incremental changes are typically our goal. ...

TrackJS is a small software business, and a really successful one in my opinion. We get to help developers all over the world, at companies big and small, understand their JavaScript and build better web applications. We get to work on an extremely talented cross functional team to build software...

I recently appeared on Dave Rael’s Developer on Fire podcast. The show focuses less on technical minutiae and more on the developer as a person, and their approach to adding value. I got to talk a little bit about how I think a developer can add value, and wanted to elaborate a bit more. When ...

Large web applications are almost always built by multiple teams. When the scope or scale of an application grows, there’s just no way a single team can be responsible for the entire thing. How you divide an application in to teams effectively is beyond the scope of this post, but for now let’s ...

“The only thing constant is change.” A silly platitude, but if you’re a frontend developer you can empathize. If it’s not JavaScript frameworks that are changing, it’s the language itself. If it’s not the HTML spec changing, it’s the protocol the markup is served with. The web moves fast. Th...

I built my first website in 1995. It was a simple affair consisting of markup I wrote with notepad.exe. Deployment involved FTPing the files to GeoCities. The code is long gone, but that site would still render the same with Chrome in 2018 as it did with Netscape in 1995. Heck, even the first...

The ability to set the status of an error is our most commonly requested feature. Customers want to mark errors as fixed, or one team member wants to let the rest of the team know they are investigating an issue. There’s hundreds of reasons to set the status of an error, and until today it was ...

One of our biggest challenges is helping customers make sense of their JavaScript errors. Web applications produce a staggering number of errors, but not all of them are relevant. We have great tools like ignore rules and error groupings to help curate the data, but some noisy errors still get ...

Four years ago, we launched TrackJS as A Better Way to Track JavaScript Errors and introduced developers to the Telemetry Timeline. Many JavaScript errors are difficult to understand without the context of prior events, and TrackJS continues to provide the best information available to help you f...

Redux is an amazing JavaScript library that has become mainstream because of its simplicity, tiny 2kb size, and excellent documentation. Redux assists developers to manage state in JavaScript applications and ensure it performs consistently, regardless of the environment. However, despite Redux’...

We recently took some time to take stock of our practices and procedures following the outage at GitLab. The GitLab outage started when a developer made the easy mistake of entering a command on the wrong server. Unfortunately, that server was part of their production environment. If this could h...

It’s common to have JavaScript error messages that are almost identical, but differ by a url segment or identifier. These can be noisy, creating dozens (or hundreds) of different groupings for the same bug. To clean this up, we’ve introduced Grouping Rules that allow you to define your patterns a...

Our friends at ZingChart asked to do some data crunching on some of our data. They wanted to understand if evergreen browser releases impacted error rates overall. We were happy to provide them with some aggregate metrics regarding the recent Chrome and Firefox updates.

The web is a hostile place and our JavaScript apps will inevitably break. Browser changes, invasive plugins, unstable networks, or just plain bugs—something is going to go wrong. When it does, we need to be ready. We need to know what went wrong and how to fix it or our users just won’t come back.

We’ve been busy building new features and wanted to take a few minutes to highlight some of them. Often we’ll soft launch a feature without much fanfare to make sure it’s working as intended, so sometimes it’s not obvious when new functionality appears. So here’s some of the cool new things we’...

TrackJS turned three! It’s been amazing to help you build better JavaScript apps and pushing the boundaries of the web. We’ve learned so much from you all and want to share it.

A few weeks ago, I was at the NDC Oslo conference and I met some amazing folks. The videos are online from NDC Now and I wanted to share this one from Jonathan Mills with you. It’s got some fantastic tips for becoming more effective as a JavaScript developer, especially if its not your primary la...

We just released a TypeScript Definition file for our tracker! I know that many of you use and love Typescript. I must admit, I have been skeptical that it would be adopted. I really like writing JavaScript. But there are so many fantastic projects finding success with TypeScript and TrackJS, so ...

I was chatting with Dominik Kundel from Twilio, who had built a cool application to manage the coffee lines at NDC Oslo. You could SMS your order in and they displayed tons of analytics about the coffee served. It was a really great demonstration of their technology, and it pushed the boundaries ...

Ever since jQuery introduced deferreds, developers have used promises to manage asynchronous control flow. (I know, I know, promises pre-date jQuery, but that’s when they went mainstream). In the years since their introduction promises have been standardized and are now being implemented nativel...

The videos from Google I/O 2016 are online and there is some great content there. My favorite so far is this one from Ilya Grigorik on resilient web applications. It does a fantastic job explaining unexpected performance and network failures–way better than I did in my JavaScript Forensics talk.

A few weeks ago, we quietly released the ability for your to share your error reports publicly. We think this is really powerful, because it allows you to spread information and get feedback on your errors from a much wider audience. You can share with other teams, send a report to your boss, or ...

Loading external JavaScript is like waiting until runtime to compile an external dependency. A lot can go wrong. It’s difficult to escape the need to load external JavaScript on many of today’s web applications. Many of our sites need to compose functionality from social networks, transaction pro...

Over the past year, I’ve been touring software conferences and sharing some techniques for finding and debugging some of the most common errors on the web with a talk I call “JavaScript Forensics”. JSConfEU did a marvelous job recording and producing the talk, and I’d like to share it with you al...

With the proliferation of JavaScript transpilers, sourcemaps have become an integral part of the front-end development. If you’re using Angular 2, React, Om, Elm, or others, there are huge advantages to debugging by using sourcemaps. We’ll show you what they are, how to use them, and some things...

We’re happy to announce TrackJS Ignore Rules. The web is a noisy place, and you need tools to filter out the messages and browsers that you don’t care about. We built a simple rule engine to allow you to filter out the errors that don’t matter.

Until recently, a client-side web-application couldn’t care about SEO. The spiders that Google uses to index content didn’t know how to handle the complexities of Angular or Ember. When Googlebot came along, it expected your best stuff; not an empty DOM.

As JavaScript has grown more prevalent on the web, so have JavaScript errors. Here are the top JavaScript errors from across the web, aggregated by browser, framework, and issue. We produce this report every week, you can check it out anytime via the free Global Error Statistics report.

One of the hardest parts of client side error tracking is giving the customer meaningful signal from a sea of noise. The internet is a hostile place, and errors occur for all kinds of reasons. We noticed that sometimes, even with all of our filtering, it was possible for certain errors to slip ...

We recently discovered an issue with our suggested installation of the tracker client. Specifically, that we were using protocol-relative URLS and using the crossorigin attribute:

We love exploring the latest build tools and techniques to improve our code. Crunching, minifying, and combining code can help make our applications faster, but it also makes it really hard to debug. Source maps is a proposed spec to make debugging easier by linking our minified code with the ori...

So you’re at the bar and someone asks, “What does your software do anyway?”. How do you respond? How do you condense your technical feats into a response concise enough for the alcohol-fueled mind and amazing enough to remember tomorrow?

We’re thrilled to announce an official TrackJS Integration with Sencha ExtJS, developed with the good folks at OhmzTech. This simple wrapper will funnel the fantastic error detail into TrackJS and capture relevant context into the Telemetry Timeline.

We’ve had infrastructure problems lately, and I’m really sorry if they impacted you. Production monitoring helps you understand when problems are happening–but only when your monitors are working. Our recent availability has been totally unacceptable, and we’re upset about it.

We’ve been using Elasticsearch here for awhile. We’re thrilled to share our experiences with them, and the larger community. We wrote up a blog post with them

Todd Gardner was interviewed earlier in September by JJ Hammond and Gus Emery on JavaScript, the future of native, and legos. Check it out:

Cornell continues their series on using TrackJS by showing how they filter out noisy, unactionable errors from their reports.

The Hotel School at Cornell continues to do great things with TrackJS. They’ve written up their thoughts on identifying legitimate errors that’s very interesting.

The development team out at the Cornell School of Hotel Administration recently added TrackJS to their development process. Looks like we’ve done some good things for them, check out their review:

We’ve been working hard to release a major upgrade to our JavaScript tracker. Version 2.0.0 introduces several things you’ve been asking for, and some big ideas of our own. We’re thrilled to share it with you today.

One thing we’re constantly striving to maintain at TrackJS is a high signal-to-noise ratio. Logs filled with meaningless errors hide significant problems from developers and admins. If there’s too much noise, the important errors fall through the cracks.

We just launched some more great stuff to find and fix your errors! You have this now, log in now and check it out!

JavaScript is amazing; you are building amazing and creative web applications that no-one conceived a few years ago (except maybe Jeff). But as our webapps get larger, they get more complex, harder to debug, and difficult to reason about. Combine that with the less-than-awesome JavaScript error m...