Backend engineering blog · Mihai Nicolae

A custom middleware for Symfony Messenger to discard(not send) or not handle certain messages

hi@mnic.dev (Mihai Nicolae) — Fri, 21 Jun 2024 08:18:37 GMT

Introduction

Recently, I’ve been working on a project where I needed to implement a logic where certain messages from Symfony Messenger would not get sent or handled if they met certain criteria. It was pretty hard to find a working solution and Symfony documentation didn’t provide a clear answer, so after I found a solution, I decided to write this article to help others who might encounter the same issue.

How Symfony Messenger works

When you dispatch a message in Symfony Messenger, it goes through a couple of predefined middlewares. The order is the following:

add_bus_name_stamp_middleware
dispatch_after_current_bus
failed_message_processing_middleware
YOUR CUSTOM MIDDLEWARES
send_message
handle_message

Creating a custom message interface

Here is a basic example of how you can create a custom message interface that will work with your custom middleware.

<?php
namespace App\Messenger;

interface CustomMessageInterface
{
    public function shouldSendEmail(): bool;
}

Now, let’s create a message that implements this interface.

<?php

namespace App\Messenger;

class SendEmailMessage implements CustomMessageInterface
{
    public function __construct(private readonly string $email)
    {
    }

    // If the email ends with @test.com, we should not send the email
    public function shouldSendEmail(): bool
    {
        return false === str_ends_with($this->getEmail(), '@test.com');
    }

    public function getEmail(): ?string
    {
        return $this->email;
    }
}

Creating the custom middleware

Now, let’s create the custom middleware that will check if the message should be sent or not.

<?php

namespace App\Messenger\Middleware;

use App\Messenger\CustomMessageInterface;
use Symfony\Component\Messenger\Envelope;
use Symfony\Component\Messenger\Middleware\MiddlewareInterface;
use Symfony\Component\Messenger\Middleware\StackInterface;
use Symfony\Component\Messenger\Stamp\ReceivedStamp;

class SendEmailMiddleware implements MiddlewareInterface
{
    public function handle(Envelope $envelope, StackInterface $stack): Envelope
    {
        $message = $envelope->getMessage();

        if ($message instanceof CustomMessageInterface && false === $message->shouldSendEmail()) {
            $envelope = $envelope->with(new ReceivedStamp(__CLASS__));
        }

        return $stack->next()->handle($envelope, $stack);
    }
}

Registering the custom middleware

To register the custom middleware, you need to add it to the messenger.yaml file.

framework:
  messenger:
    buses:
      messenger.bus.default:
        middleware:
          - App\Messenger\Middleware\SendEmailMiddleware

Sending but not handling the message

If you want to send the message but not handle it, you can use the HandledStamp class instead.

$envelope = $envelope->with(new HandledStamp('Handled from email middleware',__CLASS__));

Conclusion

This is very useful when you need to implement a custom logic for lots of messages, and you don’t want to clutter your code with if statements in each handler or dispatcher. If you only have one message that needs this logic, you can implement it directly in the handler or right before the dispatch.

Note: This is also very useful when you don’t have any handlers configured for the messages, but instead sending messages async to a queueing system, like RabbitMQ. In this case, the handler can be another application which you don’t have access to

How to set up and deploy a Telegram bot as a Lambda function for free

hi@mnic.dev (Mihai Nicolae) — Sat, 01 Jun 2024 08:15:00 GMT

Introduction

Recently, I’ve had an idea to create a Telegram bot that would notify me when stocks that I am interested in have a significant change in price. I wanted to have a simple way to keep track of the stocks that I am interested in without having to check the stock market every day.

This is just my use case, but you can adapt this guide to any other use case that you might have in mind.

Prerequisites

Before we start, make sure you have the following:

An AWS account with free tier activated
Terraform installed on your machine. You can find the installation instructions here For macOS users, you can install Terraform using Homebrew:
```
brew install terraform
```
AWS CLI installed on your machine. You can find the installation instructions here For macOS users, you can install the AWS CLI using the following commands:
```
curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
sudo installer -pkg AWSCLIV2.pkg -target /
```
Python, GO, or any other programming language that you are comfortable with. In this guide, I will use Python to create the logic of the Lambda function.
For easier development and deployment, also install make on your machine. You can find the installation instructions here For macOS users, you can install make using Homebrew:
```
brew install make
```
A Telegram account

Create the actual Telegram bot

The first step is to create a new bot using the BotFather on Telegram. You can find the BotFather by searching for it on Telegram.

Just start a new chat with this Bot and type /newbot. The BotFather will guide you through the process of creating a new bot. After the bot is created, you will receive a token that you will need later, so make sure to save it.

You can see an example of how to create a new bot using the BotFather in the image below:

Create your project

Handler

Create a new directory on your machine where you will store all the necessary files for this project. You can name this directory telegram_bot. In this directory, create a new directory named code.

Inside the code directory, create a new file named lambda_function.py. This file will contain the logic of the Lambda function. It must also declare the lambda_handler function, which is the entry point for the Lambda function. For this example, I tried to keep it simple and only send back the message that the users send. If you want the logic of the stock prices change, you can check the GitHub repository here.

Here is the content of my lambda_function.py file:

import boto3
import requests
import json

secretsmanager = boto3.client('secretsmanager')

def get_secret(secret_name):
    try:
        response = secretsmanager.get_secret_value(SecretId=secret_name)
        secret = json.loads(response['SecretString'])
        return secret
    except Exception as e:
        print(f"Error retrieving secret: {e}")
        return None

# Retrieve the Telegram token from Secrets Manager
secrets = get_secret("telegram/bot_token")

TELEGRAM_TOKEN = secrets.get('TELEGRAM_TOKEN') if secrets else None
TELEGRAM_API_URL = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/" if TELEGRAM_TOKEN else None

def lambda_handler(event, context):
    if 'body' in event:
        try:
            body = json.loads(event['body'])
            if 'message' in body:
                chat_id = body['message']['chat']['id']
                text = body['message']['text']
                send_message(chat_id, text)
        except json.JSONDecodeError:
            print("Failed to decode JSON body")
    else:
        # Check if the event is coming from EventBridge
        if 'source' in event and event['source'] == 'aws.events':
            #Do something else when event is from EventBridge
            print("Event from EventBridge")
        else:
            print("Unhandled event type")
            return {
                'statusCode': 400,
                'body': json.dumps('Bad Request')
            }

    return {
        'statusCode': 200,
        'body': json.dumps('Success')
    }

def send_message(chat_id, text):
    url = TELEGRAM_API_URL + "sendMessage"
    payload = {'chat_id': chat_id, 'text': text, 'parse_mode': 'Markdown'}
    try:
        response = requests.post(url, json=payload)
        response.raise_for_status()
    except requests.RequestException as e:
        print(f"Error sending message: {e}")

This repo contains also the configs for EventBride, to trigger the lambda function periodically on Stock Market opening hours and it also saves the stocks registered by the users in DynamoDB and sends notifications to all the users.

requirements.txt

Create a new file named requirements.txt in the same directory. This file will contain the dependencies that the Lambda function needs to have installed. my file:

requests
boto3
urllib3==1.26.6
finnhub-python

Note: The finnhub-python package is used to get the stock prices. The boto3 package is used to interact with AWS services.

Makefile

Create a new file named Makefile in the same directory. This file will contain the commands that we will use to build and deploy the Lambda function.

Here is the content of my Makefile that you can also use:

# This creates the AWS resources defined in the terraform file
apply:
	terraform init
	terraform apply -auto-approve

# This command is used to zip the code and upload it to S3
zip-code:
	zip -r telegram_bot.zip ./code/*
	aws s3 cp telegram_bot.zip s3://telegram-bot-lambda-bucket/telegram_bot.zip

# This command is used to install the dependencies that will be used as a layer for the lambda function and upload them to S3
zip-layer:
	pip3 install --no-cache-dir -r ./code/requirements.txt -t ./python
	zip -r python.zip ./python/*
	aws s3 cp python.zip s3://telegram-bot-lambda-bucket/python.zip
	terraform apply -auto-approve

Terraform

This file is used to create the necessary resources for the Lambda function. As I previously said, I will keep it simple and only create the Lambda function. If you want the full example, checkout the GitHub repository.

Create a new file named main.tf in the root directory. This file will contain the Terraform configuration for the Lambda function.

Here is the content of my main.tf file:

provider "aws" {
  region = "eu-central-1"
}

resource "aws_iam_role" "lambda_role" {
  name = "lambda_role"

  assume_role_policy = jsonencode({
    Version = "2012-10-17",
    Statement = [{
      Effect = "Allow",
      Principal = {
        Service = "lambda.amazonaws.com"
      },
      Action = "sts:AssumeRole"
    }]
  })
}

resource "aws_iam_role_policy_attachment" "lambda_policy" {
  role       = aws_iam_role.lambda_role.name
  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
}

resource "aws_s3_bucket" "lambda_bucket" {
  bucket = "telegram-bot-lambda-bucket"
}

resource "aws_lambda_function" "telegram_bot" {
  s3_bucket        = aws_s3_bucket.lambda_bucket.bucket
  s3_key           = "telegram_bot.zip"
  function_name    = "telegram_bot"
  role             = aws_iam_role.lambda_role.arn
  handler          = "lambda_function.lambda_handler"
  runtime          = "python3.8"
  timeout          = 60
}

resource "aws_lambda_layer_version" "my_layer" {
  layer_name = "my-bot-layer"
  s3_bucket        = aws_s3_bucket.lambda_bucket.bucket
  s3_key           = "python.zip"
  compatible_runtimes = ["python3.8"]
}

Deploy the Lambda function and layer

Now that we have all the necessary files and configurations, we can deploy the Lambda function. First, configure your AWS CLI by running the following command:

aws configure

If you don’t manage to configure it, check out this YouTube tutorial: AWS CLI Configuration

Then, you need to run the following command to create the necessary resources in AWS:

make apply

After the resources are created, you can run the following command to zip the code and the layer and upload them to S3:

make zip-code
make zip-layer

After the code and the layer are uploaded to S3, you can go to the AWS console and check if the Lambda function was created successfully.

IAM Role

Go to the AWS console and search for IAM. Click on Roles and search for the role that was created by Terraform. You should see a role named lambda_role. Click on it and attach the following policies that will allow your Lambda function to interact with other AWS services:

Create a new Function URL

To receive messages from Telegram, you need to set up a webhook. You can do this by sending a request to the Telegram API, but first, you need to have a public URL for your lambda function. Recently, AWS introduced the Function urls that allows you to create a public URL for your Lambda function.

Go to the AWS console, search for Lambda, click on Configuration, and then click on Function urls.

In here, you can create a new URL for your Lambda function. After the URL is created, you can use it to set up the Telegram webhook.

Set up the Telegram webhook

This is pretty simple, you just need to send a request to the Telegram API to set up the webhook. This webhook will tell telegram to send all the messages for the bot to the URL that you just created. You can do this by running the following command in your terminal:

curl https://api.telegram.org/botTOKEN/setWebhook\?url\=FUNCTION_URL/

Just replace TOKEN with the token that you received from the BotFather and FUNCTION_URL with the URL that you received from AWS.

Setting up the Secrets Manager

One more thing that you need to do is to set up the Telegram token in the Secrets Manager. Go to the AWS console, search for Secrets Manager, and click on Store a new secret. Name it telegram/bot_token and add a new key-value pair with the key TELEGRAM_TOKEN and the value the token that you received from the BotFather.

Testing the Lambda function

If everything was configured correctly, you can test the Lambda function by sending a message to your bot on Telegram. It should respond with the same message that you sent.

Conclusion

In this guide, I showed you how to set up and deploy a Telegram bot as a Lambda function with free resources, using Terraform. If you encounter any issues, feel free to ping me and I will gladly help you. You can find me on my socials in the footer of this website.

How analyzing your codebase can save you time and money

hi@mnic.dev (Mihai Nicolae) — Tue, 13 Feb 2024 18:15:00 GMT

Introduction

Recently, I’ve come across a book entitled "Your Code as a Crime Scene", written by Adam Tornhill. You can find the book here.

It is a book that I highly recommend to anyone who is interested in software development, especially if you are a software engineer, team lead, or architect.

So, what is actually a hotspot?

To gain a deeper understanding of this concept, let’s take a moment to explore the realm of the criminal world.

Locations where crimes occur are rarely just a simple point on a map. They usually follow a pattern and are often near the actual location of the offender.

Maybe you’ve seen this in movies, where detectives use a map with pins and strings to connect them or draw big circles to see where the crimes overlap. In the software world, just like in the criminal one, we can also pinpoint hotspots.

These are the places in our codebase that can cost us a lot of time and money if they are not addressed properly.

OK, but how to find hotspots in your project?

The first step is to identify the needs of your project. The techniques can vary depending on the size of the codebase, the number of developers, the complexity of the project, and so on.

CodeCity

CodeCity is a simple and intuitive tool for software analysis.

It provides a visual representation of your codebase, where each package is represented as a city block and each class is depicted as a building. The height of the building corresponds to the number of methods, while the base represents the number of attributes.

If you want to know more about CodeCity, or even try it out, you can find it here.

Below is an example of a CodeCity visualization:

In this visualization, we can easily identify the hotspots. The tallest building, which is also the most intense in color, represents the biggest hotspot in this case, which would be a good starting point for further analysis.

Note: While CodeCity is a fun tool, you should use it with other tools and techniques to get a complete picture of your threats and potential bottlenecks.

CodeScene

Researchers proved that the frequent changes to the same code generally indicate declining quality of the code.

So, in order to have a clear picture of our possible bottlenecks, we need to combine the complexity of the code with the frequency of changes.

Here is where CodeScene comes into play.

It connects to your GIT provider and analyzes the commits and pull requests to provide a clear visualization of your codebase.

It also provides a hotspot analysis, which is a great starting point for identifying the areas that need attention.

I took the liberty to fork the doctrine/orm repository and analyze it with CodeScene:

We can already see that doctrine/orm has a lot of hotspots, especially in the src directory.

One of the most interesting ones is the UnitOfWork.php file, which has been the subject of many changes and refactorings in the past. Its complexity grew exponentially over time, along with tight coupling with other classes.

Tip: CodeScene is actually developed by Adam Tornhill! You can have fun with it here.

Preventing measures

While most of the disasters cannot be predicted in real life, we have the privilege to prevent some of them in the software world.

I will present some of the most important measures that any developer or team lead should take which require minimal to none starting costs but can have huge impacts in the long run.

1. Quality of Code Reviews

Code Review should take an important part in the development process. A good and thorough code review can prevent a lot of hotspots from appearing in the first place.

What makes a code review effective:

A clear picture: The reviewer should have a clear picture of the feature or bug that is being addressed. It should understand both, the business and the technical requirements.
Live code reviews: Always aim to have live code reviews. It doesn’t matter if you work in the same office or remotely. If you do code review while talking to the author, you will have a better understanding of the changes and the author’s intentions.

2. Pair Programming

Pair programming is a technique where two developers work on the same code at the same time. It is a great way to prevent hotspots since the code is being reviewed by someone else in real-time.

3. Static Analysis

There are a lot of tools that can help you with static analysis when you write your code. For instance, in JetBrains IDEs, you can use the SonarLint extension to analyze your code on the fly.

Tip: I use the SonarLint extension along with the InlineError one. It is a great combination that helps visualize the issues in the code.

Here is a dummy example I wrote just to show you how it looks like:

The SonarLint extension identifies unused variables, popular code smells, and also calculates the cognitive complexity of your methods.

4. Team Knowledge

It is important to have a team that is knowledgeable about the codebase. This can be achieved by having a good onboarding process with strong confluence documentations for all the business and technical flows.

One good starting point is also to have a common knowledge sharing session, where each team member presents something notable he/she implemented in the past weeks.

Finding authors that contributed a lot to the codebase but are no longer in the team can also be a good starting point. Those areas are usually the most problematic ones since the current team members are not familiar with the code, and that area of the code may be a ticking time bomb.

5. Refactoring

Refactoring can also be a good example of how you can keep your code clean and avoid disasters.

Note: Large-scale refactorings should always be done only when you have real benefits from them. The costs of refactoring and the potential risks that come with it may outweigh the benefits.