Forem: mohieddin

Event tracking with Mixpanel and NodeJs, The Callback in Async scope magic!

mohieddin — Mon, 21 Mar 2022 16:29:14 +0000

Hello World!

It's been a while (a long long time ago 🙄 ) since my last post, long story short there is no specific reason, just me lazy to post.

Note:

I'm not going through what is Mixpanel and why we decided to use it at Supahands, the focus here is on a challenge we faced and how we tackled it

Use case:

We've been working on integrating an event tracking service to one of our backend APIs, so we can have a clear eye on our users' behaviour and interaction with our platform, so we can prioritise features and manage building iterations in a more user-oriented way, and our integration of choice is Mixpanel

Challenge we are trying to solve

Mixpanel NodeJs library's functions are built as callback and our code base is an ExpressJs app encapsulated in an AWS Lambda using the serverless framework "I'll share why in another post" and in our code base we are using async/await, And the question at that time was how to integrate the callback behaviour inside an async/await function?

What we did first 👇


// Mixpanel Service
// path: /src/services/mixpanel-service.js

const mixpanel = require('mixpanel').init('<TOKEN>');

// We tried to wrap it with async/await to consist the
// codebase style and to avoid callback hell.
async function track(event, properties) {
  await mixpanel.track(event, properties)
}

module.exports = { track }


// Customer Model
// path: /src/models/customer-model.js

// database interface instance
// we are using knex.js -> https://knexjs.org
const db = require('../configs/database-configs.js');

const mixpanel = require('../services/mixpanel-service.js');

class Customer extends User {
  constructor(fullName, email, address, brand) {
    super(fullName, email, address);
  }

  async create() {
    const { fullName, email, address, brand } = this;
    try {
      await db('customers').insert({ fullName, email, address, brand });
      await mixpanel.track('customer creation succeed', { fullName, email, address, brand });
    } catch (error) {
      await mixpanel.track('customer creation failed', { fullName, email, address, brand });
    }
  }
}

The above code did nothing in terms of tracking, and it throw no error and the function did not behave as an async/await function even after we wrapped it with async/await, because the execution is not ruled by the wrapper.

As a syntax and code execution sequence, there is nothing wrong, but the code execution behaviour does not match the expected behaviour.

The simple straightforward solution we considered was using promisify to force mixpanel-service to adapt the async/await ( returning promise ) behaviour by wrapping the track function with promisify to change it to a function that returns a promise.


// Mixpanel Service
// path: /src/services/mixpanel-service.js

const util = require('util');
const mixpanel = require('mixpanel').init('<TOKEN>');
const trackAsync = util.promisify(mixpanel.track);

// We tried to wrap it with async/await to consist the
// codebase style and to avoid callback hell.
async function track(event, properties) {
  await trackAsync(event, properties)
}

module.exports = { track }


// Customer Model
// path: /src/models/customer-model.js

// database interface instance
// we are using knex.js -> https://knexjs.org
const db = require('../configs/database-configs.js');

const mixpanel = require('../services/mixpanel-service.js');

class Customer extends User {
  constructor(fullName, email, address, brand) {
    super(fullName, email, address);
  }

  async create() {
    const { fullName, email, address, brand } = this;
    try {
      await db('customers').insert({ fullName, email, address, brand });
      await mixpanel.track('customer creation succeed', { fullName, email, address, brand });
    } catch (error) {
      await mixpanel.track('customer creation failed', { fullName, email, address, brand });
    }
  }
}

The above code matched the expected output and logged the events inside our Mixpanel project's dashboard.

Takeaway notes:

Read the library that you want to use in your project and understand its behaviour and implementations.
Wrapping callback-based function in async/await block will not change that function behaviour if there is no promise implementation to that function
Learning by doing and researching is a great joy.

Sorry in advance for any grammar mistake or typo 👻.
If you have any concerns or feedback I'm all ears👂.

cheers.

Baby Steps in Golang

mohieddin — Wed, 22 Apr 2020 10:36:37 +0000

Workplace is a proprietary product of Supahands.
Our Business Operations Managers (BOMs) use the platform to manage our projects and SupaAgents (Supahands’ managed workforce).

One of the main highlights of Workplace is labels — a feature that allows BOMs to match SupaAgents to projects depending on their skills and qualifications.

Labels help with describing a SupaAgent’s skills and for our BOMs to identify SupaAgents with relevant skills that are required of them to join a project.

Labels display the skills of a SupaAgent and requirements of a project.

For example, Project 5UP4 requires SupaAgents with annotation skills, therefore, BOMs can change the settings of the project, SupaAgents without the label tag to their account will not be able to join the project.

The problem we were trying to solve…

We experienced unexpected growth in September, where we had three times the number of SupaAgents coming on to Workplace. The platform had to load every single SupaAgent’s information, putting a strain on the system.

Besides loading issues, the server was not responding due to the large amount of data it had to cope with. We initially attempted to solve the issue by increasing the number of CPUs that run our microservice but eventually came to realize that it was costly and inefficient to do so.

We knew we had to take the next course of action ⁠ — to rewrite the microservice of Workplace.

The previous microservice was built using Java (spring-boot framework) and GraphQL (neo4j), which were not suitable choices for rapid scaling. The software architecture was built in a way that could only allow us to handle the amount of SupaAgents that we had at that time. Naturally, as the number of users on the platform grew, Workplace began breaking.

While faster load time was the priority in the reason for rewriting the microservice. Additionally, we needed to make changes to how information is displayed. The current view of labels for Projects and SupaAgents are presented separately. We needed to have them on display side by side as it allows our BOMs to match our Projects and SupaAgents faster.

We started with looking for other programming languages, we initially looked at Typescript, C# as solutions. However, after taking a look at what other at scale tech companies were using as well and comparing the available languages from the criteria of succinctness, efficiency, performance, power, reliability and community support, we arrived at using Golang.

Why Golang?

Golang is a procedural programming language developed in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson at Google. It was launched in 2009 as an open-source programming language.

Golang fulfilled all of our criteria as well as having the bonus of being open source and the community that grew around it was a vibrant, welcoming and fun group.

Roadblocks faced while learning Golang

Golang is a new programming language within the engineering team. We had to learn it from scratch, from the concepts of how the language is built on to the actual application of it.

It was only natural that we faced roadblocks along the way…

1. Syntax

Golang syntax is new for a person with a background in python, ruby on rails and javascript, in terms of defining functions, manipulating arrays and defining classes.

2. Golang’s representation of Object-Oriented Programming

Golang’s representation of Object Oriented Programming concepts in a different way so you have structs instead of classes and you can apply inheritance by embedding the parent structure inside child structure.

For example, to define a class in Javascript, C#, Typescript, you can use the keyword Class

But on Golang it’s a different class represented by a data-structure called struct

Another example is an inheritance, to inherit from a class in PHP, we can use the keyword extends

In C#, we can use the symbol “ : ”

But in Golang, you are embedding a struct into another one, ex:

All in all, Golang is a solid programming language, providing simplicity, efficiency, speed, and reliability with less code to write. As I’ve just started my Golang journey, I have received large community support, so it’s easy to find an answer to any questions you may have. You can spend three to four hours to learn the concepts of the language, then you can easily start building applications because Golang provides a large pool of packages and frameworks to make your life easier, and the good thing most of (if not all) packages are open-source, so you can easily modify them to serve your needs.