or: How to integrate SPM with Meteor

It's been far too long since I wrote a post, life gets super busy sometimes.
At any rate, today I'm going to be writing about something that is searched by quite a lot of people:
An Alternative to Kadira.

What is Kadira?

Kadira is the only Cloud-based Meteor Debugging tool out there.
If you're familiar with tools like New Relic, Kadira is basically a lean version of that.
It allows you to see live bugs/errors coming from your application, with a full backtrace so you know which part of the application is causing the problem (to some extent). It also has limited tools for reporting/statistics, so you can see if there's a great uptick of bugs lately or a certain type of bug after introducing a new feature.

Why look for a Kadira Alternative?

It was recently published that the founder and maintainer of Kadira has moved away from Meteor.
Leaving the fate of Kadira very uncertain. In fact, a full year and a half before the announcement,
there weren't any changes to Kadira's feature set.
What disappointed me the most was that Kadira's source wasn't released, so on the one hand it won't be maintained any longer, but on the other hand, there's no option for the community to step in.

On top of that issue, Kadira is quite limited, searching/navigating through issues is very difficult and at times - impossible. there's a lot of repeated bugs that are not registered correctly (without any backtrace or info), making it very hard to find which is a Kadira bug, and which is an actual bug in my application.

That's why I thought that it was time to seek an alternative.

Who plays nice with Meteor?

Most of the major services (New Relic, AppDynamics), didn't support Meteor, or if they did - it was a very limited support, and considering the price point (in the hundreds, sometimes thousands monthly), I expected to have a complete turnkey solution with minimal integration issues.

After looking at a few posibilities, I decided to go with SPM from Sematext.
This tool is not the most popular debugging tool in the world, but their API is clear, easy to use, and their interface is quite nice as well.

Implementing SPM Debugger in Meteor

This can be done with 2 easy steps

1. Add the following to your package.js or .meteor/packages for chaotic packageless projects (SHAME, SHAME):

   1
   2
   3
   4
   5
   6
   Npm.depends({
   	'spm-agent-nodejs': '1.30.2',
   	'winston': '2.3.0',
   	'winston-logsene': '1.2.1'
   })
   		
   

2. Add the following code to your Server-side code:

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   /* Loading SPM Monitoring Agent */
   
   var spmStart = function() {
     process.env.NODE_OPTIONS = '-r spm-agent-nodejs';
     var logsene_token = LOGSENE_TOKEN; //Insert Logsene token here
     var spmAgent = Npm.require('spm-agent-nodejs');
   
     //Logsene
     var winston = Npm.require('winston');
     var logsene = Npm.require('winston-logsene');
     var logger = new winston.Logger();
     logger.add(logsene, {token: logsene_token, type: 'logs'});
   
     // Overriding Meteor Error function, simply adding the
     // logger before the original function runs
     var util = Npm.require('utils');
     var errorFunc = Meteor.Error;
     Meteor.Error = function(error, reason, details) {
       logger.error('Error: ' + error, {
         error: error,
         reason: reason,
         details: details,
         stack: Error().stack,
         tags: ['error', 'winston']
       });
       errorFunc.call(this, error, reason, details);
     };
     util.inherits(Meteor.Error, errorFunc);
   };
   
   spmStart();
   		
   

   Special thanks to Wojtek Krysiak for adding inheritance here
   I suggest creating a separate file in your Meteor Project (or better yet, a separate package!)

That's it! Meteor errors AND Performance Information should be visible on your SPM dashboard.
I might organize the code snippet and add it to GitHub at a certain point (fingers crossed).

Until next time!