Forem: Suharxxxx

Building a WhatsApp Multi-Instance REST API with Go, Echo, and Whatsmeow 🚀

Suharxxxx — Sun, 07 Dec 2025 17:15:15 +0000

Introduction
Ever needed to manage multiple WhatsApp accounts programmatically? Whether you're building a customer service platform, notification system, or automation tool, handling multiple WhatsApp instances can be challenging.

In this article, I'll share my journey building SUDEVWA - a production-ready WhatsApp Multi-Instance REST API using Go, Echo framework, and the powerful Whatsmeow library.

🎯 What We're Building
A REST API that can:

✅ Manage multiple WhatsApp accounts simultaneously
✅ Send/receive messages in real-time via WebSocket
✅ Handle media files (images, videos, documents)
✅ Maintain persistent sessions across server restarts
✅ Auto-reconnect disconnected instances

🛠️ Tech Stack
Go 1.21+ - Performance and concurrency
Echo v4 - Fast HTTP router
Whatsmeow - WhatsApp Web multidevice API
PostgreSQL - Session persistence
Gorilla WebSocket - Real-time communication

┌─────────────┐
│ Client │
└──────┬──────┘
│ HTTP/WebSocket
┌──────▼──────┐
│ Echo API │
├─────────────┤
│ Service │ ← Multi-instance manager
│ Layer │
├─────────────┤
│ Whatsmeow │ ← WhatsApp protocol
└──────┬──────┘
│
┌──────▼──────┐
│ PostgreSQL │ ← Session storage
└─────────────┘

🚀 Key Features Implementation

Multi-Instance Management

Each WhatsApp account is isolated as an "instance" with its own:
Database connection
Whatsmeow client
Event handlers
Session data

type Session struct {
    InstanceID  string
    Client      *whatsmeow.Client
    IsConnected bool
    JID         string
}

var sessions = make(map[string]*Session)

Real-time Message Listener via WebSocket

Two WebSocket endpoints for different use cases:

Global WebSocket (/ws) - System events:

QR code generation
Login/logout events
Connection status changes
Instance-specific WebSocket (/api/listen/:instanceId) - Message inbox:
Incoming messages for specific instance

// Broadcast incoming messages to WebSocket clients
case *events.Message:
    Realtime.BroadcastToInstance(instanceID, map[string]interface{}{
        "event":       "incoming_message",
        "instance_id": instanceID,
        "from":        v.Info.Sender.String(),
        "message":     messageText,
        "timestamp":   v.Info.Timestamp.Unix(),
        "is_group":    v.Info.IsGroup,
    })

Persistent Sessions with Auto-Reconnect

Sessions survive server restarts by storing device data in PostgreSQL:

func LoadAllDevices() error {
    devices, err := model.GetAllConnectedInstances()
    for _, device := range devices {
        // Recreate whatsmeow client
        client := whatsmeow.NewClient(device.Store, waLog.Stdout("Client", "INFO", true))
        client.AddEventHandler(eventHandler(device.InstanceID))

        // Reconnect
        if err := client.Connect(); err != nil {
            log.Printf("Failed to reconnect %s: %v", device.InstanceID, err)
        }
    }
}

Ping-based WebSocket Keep-Alive

Prevent connection timeouts with automatic ping/pong:

func (c *Client) WritePump() {
    ticker := time.NewTicker(5 * time.Minute)
    defer ticker.Stop()

    for {
        select {
        case event := <-c.send:
            // Send message

        case <-ticker.C:
            // Send ping every 5 minutes
            if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
                return
            }
        }
    }
}

Flexible Message Sending

Send messages by instance ID or phone number:

// By instance ID
POST /api/send/:instanceId
{
    "to": "628123456789",
    "message": "Hello!"
}

// By phone number (finds instance automatically)
POST /api/by-number/:phoneNumber
{
    "to": "628987654321",
    "message": "Hi there!"
}

📊 WebSocket Real-time Events
Example incoming message event:

{
  "event": "incoming_message",
  "timestamp": "2025-12-08T00:00:00Z",
  "data": {
    "instance_id": "instance123",
    "from": "6281234567890@s.whatsapp.net",
    "from_me": false,
    "message": "Hello World",
    "timestamp": 1733587980,
    "is_group": false,
    "message_id": "3EB0ABC123DEF456",
    "push_name": "John Doe"
  }
}

🔐 Security & Best Practices

JWT Authentication - Protect all API endpoints
Rate Limiting - 10 requests/second per IP
CORS Configuration - Whitelist allowed origins
Number Validation - Verify WhatsApp registration before sending
Graceful Shutdown - Proper cleanup on logout

🎯 Use Cases

Customer Service - Multi-agent support with different WhatsApp numbers
Notifications - Send alerts from multiple business accounts
Chatbots - Build conversational AI with WhatsApp
Automation - Scheduled messages, bulk sending
Monitoring - Real-time message tracking dashboard

📈 Performance Considerations

Goroutines for concurrent instance management
Channel-based event broadcasting
Connection pooling for PostgreSQL
Memory-efficient session storage
Auto-cleanup of ghost WebSocket connections (15min timeout)

🚧 Challenges & Solutions
Challenge 1: Session Persistence
Problem: Sessions lost on server restart
Solution: Store Whatsmeow device data in PostgreSQL, reload on startup

Challenge 2: Memory Leaks from Dead Connections
Problem: WebSocket connections not properly closed
Solution: Ping/pong mechanism with 15-minute timeout

Challenge 3: Race Conditions with Multiple Instances
Problem: Concurrent map access
Solution: sync.RWMutex for thread-safe operations

🔮 What's Next?
📋 Webhook support for incoming messages
👥 Group management (create, add members, etc.)
📱 Status/story posting
📊 Analytics dashboard
🔄 Message templates for bulk sending
📦 Try It Yourself

The project is open-source and available on GitHub:

suharyadi2112 / Sudev-WhatsApp-API

WhatsApp Multi-Instance Manager A robust WhatsApp automation tool built with Go and Whatsmeow, designed for managing multiple WhatsApp instances with real-time monitoring and message handling capabilities.

SUDEVWA - WhatsApp Multi-Instance API (Go/Golang)

WhatsApp Automation API | Multi-Device Management | Real-time WebSocket | Go + Echo + Whatsmeow

REST API for WhatsApp Web automation, multi-instance management, and real-time messaging built with Go (Golang), Echo framework, and whatsmeow library.

🔍 Keywords

WhatsApp API, WhatsApp Bot, Multi-instance WhatsApp, WhatsApp Automation, Go WhatsApp, Whatsmeow, WebSocket Real-time, REST API, PostgreSQL, Echo Framework

✨ Key Features

🔐 Authentication & Instance Management

Multi-instance — manage multiple WhatsApp numbers simultaneously
QR Code authentication — generate QR for device pairing
Persistent sessions — sessions survive restart, stored in PostgreSQL
Auto-reconnect — instances automatically reconnect after server restart
Instance reusability — logged out instances can scan QR again without creating new instance
Instance availability control — used flag for external app integration, keterangan for notes/tracking
Graceful logout — complete cleanup (device store + session memory)
Circle/group management — organize instances by…

View on GitHub

# Clone repository
git clone https://github.com/suharyadi2112/Sudev-Whatsapp-Tools.git
cd Sudev-Whatsapp-Tools

# Setup environment
cp .env.example .env
# Edit .env with your PostgreSQL credentials

# Run migrations
go run main.go --createschema

# Start server
go run main.go

Visit http://localhost:2121 and you're ready! 🎉

💡 Key Takeaways
Whatsmeow makes WhatsApp automation accessible in Go

WebSocket perfect for real-time messaging features

PostgreSQL essential for session persistence

Multi-instance architecture enables scalability

Event-driven design keeps code maintainable

🤝 Contribute
Found this useful? Consider:

⭐ Star the repository
🐛 Report issues
🔧 Submit pull requests
💬 Share feedback
📚 Resources

Whatsmeow Documentation

Echo Framework Guide
Gorilla WebSocket

What's your experience with WhatsApp automation? Have questions about the implementation? Drop a comment below! 👇

golang #go #whatsapp #api #websocket #opensource #tutorial

Web Application Debugging with Sentry Session Replay: Comprehensive Walkthrough 🚀🚀

Suharxxxx — Sat, 26 Aug 2023 06:50:00 +0000

What Is ?? 🧐🤔

Sentry Session Replay is a feature that allows recording every user action within our application. In this article, we will explain in simple terms how Session Replay Sentry can replay user actions to help us understand and troubleshoot issues Session Replay Sentry. Let's learn how Session Replay Sentry can enhance the quality of our application! ⚡

We have discussed the steps for installing Sentry to manage error logs Configuration Sentry Golang, which include:

Creating a Sentry account.
Connecting the application to Sentry using an API key (Golang).
Integrating the Sentry SDK into the application code to track and record error logs (Golang).

However, at this point, we will delve into an additional feature of Sentry known as Sentry Session Replay.

The main purpose of 😲🤔

Using Sentry Session Replay is to record and replay your sessions within the application. With this feature, you can accurately review what happened in your experience before the occurrence of an error or problematic situation. This helps you and the development team identify the causes of errors more quickly, understand your interactions with the interface, and make necessary improvements to enhance your overall experience. Session Replay Overview: Watch User Sessions to Confirm Issues and Debug Faster

Lets Start 🚦🚗

Make sure you've got the tools. The installation is a breeze, no worries. Unlike the official Sentry Setup Session Replay docs Pre-requisites(Install), which use NPM packages, we're taking a scenic route using CDN bundles Performance & Replay Bundle or Errors & Replay Bundle. Just add the Sentry loader script to your web page and you're set!

Place the CDN loader script for Errors & Replay Bundle above your page (marked with a red box).



<script
  src="https://browser.sentry-cdn.com/7.64.0/bundle.replay.min.js"
  integrity="sha384-eIBhmVs6phxABM7+IIv3ns4W+ShqowNbNrv8gOqCw8sqxfvNjsA5M9c64D5Oobcv"
  crossorigin="anonymous"
></script>

<script>
  const replay = new Sentry.Replay({
    maskAllText: false,
    blockAllMedia: true,
  });
    Sentry.init({
        dsn: "https://25a443e0b56147dd9f7552aa5ac7b14a@o450xxxxxxxxxxxx.ingest.sentry.io/4504378428096512",
            replaysSessionSampleRate: 1.0,
            replaysOnErrorSampleRate: 1.0,
        integrations: [
            replay
        ],
    });
    replay.start();
</script>

Now, let's dissect this code a bit.🤯



const replay = new Sentry.Replay({
  maskAllText: false,
  blockAllMedia: true,
});

This part makes a new Replay class instance from Sentry.Replay() library. Two options:

maskAllText is set to false to keep text visible.
blockAllMedia is set to true to hide images/videos.



Sentry.init({
        dsn: "https://25a443e0b56147dd9f7552aa5ac7b14a@o450xxxxxxxxxxxx.ingest.sentry.io/4504378428096512",
            replaysSessionSampleRate: 1.0,
            replaysOnErrorSampleRate: 1.0,
        integrations: [
            replay
        ],
    });

Set things in motion with Sentry.init(), swapping out dsn:"https://YOUR_DSN_HERE" with your unique DSN.

if u no have DSN Create a new project by clicking here Configuration Sentry Golang.

Slide the replaysSessionSampleRate to 1.0, capturing all sessions for the record
Adjust replaysOnErrorSampleRate to 1.0 as well, ensuring all errors have their moment.

for the complete details about replaysSessionSampleRate, replaysOnErrorSampleRate and other configurations, you can check out General Integration Configuration.

Integrate our crafted replay object into Sentry with [replay].

const replay = new Sentry.Replay()



replay.start();

The code replay.start(); gets the replay going. It's like hitting play to start the replay Manually Starting Replay.

We're going to do some testing. To intentionally cause an error, we need to input the function myUndefinedFunction(). This code will trigger an error because the myUndefinedFunction function hasn't been defined. The resulting error will be recorded in the Sentry Session Replay."

myUndefinedFunction() function is documented in the Sentry documentation. You can find the details at this link Pre-requisites (Set Up).

The important thing to remember is that the function

myUndefinedFunction(); is purposely put right after replay.start();.
This is done to intentionally trigger an error caused by the undefined myUndefinedFunction.

This careful arrangement is vital for effectively recording the error during Sentry Session Replay.

Give it a shot! 🚀🎇

Putting our earlier code to the test. Let's see the results!

During this testing phase, I'm employing a basic application that I've personally crafted. This application will serve as the platform for capturing and recording session replays using Sentry

Make sure the Loader Script and the function call to Sentry have been seamlessly integrated into your application. This provides a strong setup for running thorough tests.

We're about to begin testing, so make sure you've already created a project in Sentry.

If you haven't, you can check out the reference Create Project Sentry Configuration Sentry Golang

Head to the Replay tab in the Sentry menu. It's essential for the next steps.

After the author ran a series of tests, the dashboard will now look like this.

Running ur Project Application, to run the app with the included Sentry Session Replay, just start it. This turns on Sentry replay for testing. Remember, the added myUndefinedFunction() intentionally creates an error that Sentry will record during replay.

To see the error causing myUndefinedFunction() to be undefined, open the console in the Inspect Element section. This is what will be recorded in the Sentry Session Replay.

After encountering this error, return to the Sentry Session Replay dashboard. Here, you'll be presented with a display resembling the following format, featuring various pieces of information, including:

IP address
Operating system in use
Recording duration
Number of errors
And more.

Feel free to click on any of the IP addresses to explore its comprehensive details. Within, you'll discover compelling data including:

Video-like recording of user interactions.
A chronological timeline of activities visually depicted as Breadcrumbs.
Valuable insights pinpointing the occurrence of the myUndefinedFunction() error.

Moreover, there are additional aspects that may necessitate specific configurations, potentially elaborated upon in forthcoming chapters.

DONE 🏁✨

In summary, this guide simplifies the process of setting up Sentry Session Replay. Following these steps enables you to identify concealed problems like the myUndefinedFunction() error effectively. The visualization of user interactions using videos and breadcrumbs adds significant strength to your debugging capabilities. As you dive further into Sentry session replay, you'll discover advanced configurations to elevate your error tracking proficiency. Thank you for reading and be prepared to enhance your development skills further!

References:
Sentry JavaScript Session Replay Documentation. Sentry. https://docs.sentry.io/platforms/javascript/session-replay/
Sentry JavaScript Session Replay Introduction. YouTube. https://www.youtube.com/watch?v=Zrq4kcNfAGw
Installation Guide for Sentry Session Replay. Sentry. https://docs.sentry.io/platforms/javascript/session-replay/#install
Enhance Performance with Replay Bundle. Sentry. https://docs.sentry.io/platforms/javascript/install/loader/#performance--replay-bundle
Handle Errors Using Replay Bundle. Sentry. https://docs.sentry.io/platforms/javascript/install/loader/#errors--replay-bundle
General Integration Configuration for Session Replay. Sentry. https://docs.sentry.io/platforms/javascript/session-replay/configuration/#general-integration-configuration
How to Set Up Sentry JavaScript Session Replay. Sentry. https://docs.sentry.io/platforms/javascript/session-replay/#set-up
Giphy - Animated GIFs. https://giphy.com/

AWS SES Configuration: Setting Up Email Delivery in Laravel 🚀📧

Suharxxxx — Mon, 14 Aug 2023 05:05:02 +0000

What's next ?🤔

In the previous chapter Laravel Initial Setup: Preparing for AWS SES SMTP Integration We covered the setup of Laravel for integrating AWS SES email capabilities. In the current chapter, we'll shift our focus to the AWS side. Specifically, we'll explore the necessary configurations within AWS to complement our Laravel setup. By understanding this vital aspect, you'll gain insights into managing AWS resources and ensuring seamless, dependable email delivery. Let's dive into the AWS configuration details in this chapter.

It's important to note that these steps are based on the AWS configuration as of the update in August 2023.

Let's kick 🚀🦶

Things off with a simple guide to get started on the steps.

Before proceeding, it's essential to ensure that you've already logged into the AWS Management Console, use the search feature to find "Amazon SES (Simple Email Service)" Once you're logged in, follow these steps:

Access SMTP Settings Begin by navigating to the SMTP settings within the Amazon SES service, which you can conveniently locate on the left sidebar.

SMTP Credential Once you're on the SMTP settings dashboard, just click the Create SMTP Credential button to generate the credentials needed for setting up secure email delivery via Amazon SES.

Specify User Details

Create SMTP User Set up an IAM user specifically for SMTP authentication with Amazon SES.

The author chooses to keep the username as default, without making any changes.

Click on the Create User button below to proceed with setting up your SMTP user.

Retrieve SMTP Credentials

After Create User next step you'll Retrieve SMTP Credentials In this step, you'll get the essential details you need:

IAM Username
SMTP Username
SMTP Password

You can choose to download a CSV file to keep this information stored securely for later use.

Back to Laravel

Update your .env to integrate the previously obtained SMTP Credentials, return to your Laravel's .env file, as we discussed in the previous chapter Laravel Initial Setup: Preparing for AWS SES SMTP Integration, fill in the following details :

MAIL_MAILER=smtp
MAIL_HOST=endpoint_SMTP
MAIL_PORT=587 
MAIL_USERNAME=Username_SMTP
MAIL_PASSWORD=Password_SMTP
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=Sender Mail
MAIL_FROM_NAME="${APP_NAME}"

Remember to enter the MAIL_USERNAME and MAIL_PASSWORD you obtained while creating the Specify User Details or from the downloaded CSV file. These credentials are vital for the successful integration of Amazon SES with your Laravel application.

For MAIL_HOST using SMTP endpoint example email-smtp.ap-southeast-2.amazonaws.com, MAIL_PORT using 587 and MAIL_ENCRYPTION using tls

After preparing the configuration in the .env file, the next step is to proceed with testing the email sending functionality.

Testing

Run your Laravel application on your computer with this simple command in the terminal:

php artisan serve

Your Laravel application is live on this URL and port: http://localhost:8000, you can access it using Postman or Insomnia for testing.

Before proceeding with email testing using AWS SES in Laravel, it's crucial to first register email verified identities within AWS SES.

This ensures smooth email delivery and ensures compliance with AWS SES Sandbox rules Moving out of the Amazon SES sandbox. By verifying identities in advance, you'll enable successful email communication in your Laravel application.

Not registering an email as a verified identity in AWS SES Sandbox mode may lead to error responses SMTP Response Code.

To Create Verfied Identity

Access AWS SES dashboard.
Configuration settings.
Verified identities.
Enter the Create Identity Button.

Once you've configured and verified your email identities, the next step is to send a verification email.

Verification email done

You've created the verified identity within the AWS SES Sandbox you can proceed with testing email delivery without any further obstacles.

Now, open your API testing tool, such as Insomnia Insomnia, and make a GET request to:

Please note that this route has been set up in a previous chapter Laravel Initial Setup: Preparing for AWS SES SMTP Integration during the Laravel project's initialization. It's specifically designed for testing email sending functionality within your Laravel application.

Success Send Mail

In AWS SES Sandbox mode, remember to verify both the sender and recipient email addresses. If not, you might face a 554 error, indicating email rejection. Moving out of the Amazon SES sandbox

Done

You're all set to start sending emails with AWS SES in Laravel. Don't forget to verify your email addresses in Sandbox mode for smooth delivery. If you need help, this guide is here. Thanks for reading, and enjoy email communication using AWS SES and Laravel.🚀🌞

Laravel Initial Setup: Preparing for AWS SES SMTP Integration

Suharxxxx — Thu, 10 Aug 2023 09:17:43 +0000

Welcome! In this guide, we will assist you in integrating the power of AWS SES, SMTP, and Laravel 8 Version for reliable email delivery. With easy-to-follow steps, you'll master this integration and enhance email communication efficiency. Let's get started!

Amazon Simple Email Service (SES)

Is an email platform that provides an easy, cost-effective way for you to send and receive email using your own email addresses and domains.

For example, you can send marketing emails such as special offers, transactional emails such as order confirmations, and other types of correspondence such as newsletters. When you use Amazon SES to receive mail, you can develop software solutions such as email autoresponders, email unsubscribe systems, and applications that generate customer support tickets from incoming emails. Amazon Simple Email Service (SES)

Amazon SES sends email using SMTP

Which is the most common email protocol on the internet. You can send email through Amazon SES by using a variety of SMTP-enabled programming languages and software to connect to the Amazon SES SMTP interface. This section explains how to get your Amazon SES SMTP credentials, how to send email by using the SMTP interface, and how to configure several pieces of software and mail servers to use Amazon SES for email sending. send-email-smtp

Create Mail Class

Create a new mail class using, this enables you to craft custom email templates tailored to your project's needs.

php artisan make:mail NotifyMail

NotifyMail.php created Mail folder app/Mail

namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;

class NotifyMail extends Mailable
{
    use Queueable, SerializesModels;

    public function __construct()
    {
    }
    public function build()
    {
        return $this->view('mail.setmail');
    }
}

Focus on.

This is the declaration of the build() method, which is used to construct the email content.
mail.setmail is the name of the view to be used, this name points to the view located in the resources/views/mail directory, with the file name setmail.blade.php.

Create Controller

The command generates a new controller that's specifically meant to handle sending email.

php artisan make:controller ManageMail\SendEmailController

located in the app/Http/Controllers/ManageMail directory.

namespace App\Http\Controllers\ManageMail;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Mail;
use App\Mail\NotifyMail;

class SendEmailController extends Controller
{
    public function index() {
          Mail::to('yadisuhar05@gmail.com')->send(new NotifyMail());
          if (Mail::failures()) {
               return response()->json(['msg' => 'Fail'], 500);
          }else{
               return response()->json(['msg' => 'Success'], 200);
          }
     }
}

By importing these classes, you're setting up your code to utilize Laravel's email features.

This makes it simple to send emails using the use Mail facade and to structure the content and settings of the email you want to send by utilizing the use NotifyMail class.
Mail::to Sends an email to the specified email address yadisuhar05@gmail.com, The email content are defined in the NotifyMail class.

Create Route

This route is used to test email sending through the action defined within the SendEmailController.

To create a route in Laravel, you need to import the relevant controller that contains the logic for handling the route.

use App\Http\Controllers\ManageMail\SendEmailController;

Route::get('/testmail', [SendEmailController::class, 'index']);

Create Views

Created file blade setmail.blade.php located in the resources/views/mail directory.

based on Mail Class NotifyMail.php

return $this->view('mail.setmail');

Make a simple page setmail.blade.php.

<!DOCTYPE html>
<html>
  <head>
   <title>Example Email</title>
  </head>
  <body>

   <p>AWS SES Configuration: Setting Up Email Delivery in Laravel</p>

  </body>
</html>

Set MAIL SMTP .env

In the next chapter, we'll configure Laravel's .env file, where we'll input the needed credentials, including the username and password, for sending emails through AWS SES SMTP. This step is key for ensuring secure and efficient email communication.

With all the prepared components.

mail class
controller
views
routes

You have a strong foundation for managing email sending in your Laravel project. However, it's important to note that actual email sending cannot be done until you've successfully configured AWS SES and SMTP, which will be covered in the next chapter.

Programmer's Potion, Unleashing Your Coding Powers with Morning Drinks

Suharxxxx — Thu, 22 Jun 2023 04:29:05 +0000

Starting your morning with a boost of energy is crucial for tackling complex and challenging tasks. In this article, we'll introduce you to the ideal drinks that will awaken your senses in the morning and help you face the workday with focus and high productivity. So get ready to discover beverage options that will turn you into a programmer ready to take on each morning!

Here are some suitable options to consume in the morning 😎

Water💧

Although it may seem simple, drinking water in the morning is crucial to maintain hydration after hours of not drinking during sleep. Dehydration can lead to decreased energy and concentration. So, make sure to drink a glass of water when you wake up.

A fun fact about drinking water that you may not be aware of

Approximately 70% of the human body is composed of water. This means that water is crucial for the normal functioning of our bodies.
Water helps maintain body temperature, transports nutrients to cells, lubricates joints, and eliminates waste through urine.
In addition, drinking water can improve brain function. Mild dehydration can affect concentration, mental sharpness, and mood.
By consuming enough water, we can help keep the brain focused and functioning optimally.😀

Coffee ☕

Coffee is a commonly consumed beverage in the morning by many people, including programmers. The caffeine content in coffee can help improve alertness and concentration. 😎 However, make sure not to consume too much coffee to avoid disrupting sleep or causing restlessness. 😴

A fun fact about drinking coffee that you may not be aware of

Coffee contains caffeine, a stimulant that can boost energy and help keep us awake. The caffeine content in a cup of coffee can vary, but on average, black coffee contains around 95 mg of caffeine.😉
When consumed in moderation, coffee can have some health benefits. Some studies suggest that coffee may reduce the risk of liver disease, type 2 diabetes, Parkinson's disease, and certain types of cancer. 👍

Green tea 🍵

Green tea contains lower levels of caffeine compared to coffee, but it can still provide a gentle stimulating effect. Green tea is also rich in antioxidants and has other health benefits.

A fun fact about drinking Green Tea that you may not be aware of

Matcha, a type of powdered green tea, is renowned for its vibrant green color. The intense green hue is a result of the shade-grown process used to cultivate the tea leaves. By covering the tea plants from direct sunlight for a few weeks before harvesting, the leaves produce more chlorophyll, resulting in the rich green color.
Green tea can be enjoyed hot or cold. While it is commonly consumed as a hot beverage, green tea is also delicious when brewed and served over ice. Iced green tea is a refreshing option, especially during hot summer months
In addition, green tea contains fluoride, which can contribute to maintaining good oral health. Fluoride helps strengthen tooth enamel, making it more resistant to decay and cavities. By incorporating green tea into your oral care routine, you can potentially promote healthier teeth and gums.

Smoothie 🍓

A Smoothie is a beverage made from a blend of fresh or frozen fruits, vegetables, yogurt, milk, or other ingredients. Typically, these ingredients are blended together until smooth, resulting in a thick yet creamy texture. Smoothies are often served cold and can be enhanced with the addition of ice for a refreshing sensation.

A fun fact about drinking Smoothie that you may not be aware of

High Nutrient Intake, Smoothies made from fresh ingredients like fruits and vegetables can provide a high intake of nutrients, including vitamins, minerals, fiber, and antioxidants. This helps strengthen the immune system, maintain heart health, and support overall bodily functions.
Healthy Food Alternative, Smoothies can be used as a healthy food alternative, especially for those with limited time to eat or who want to consume nutrients in a quicker and more convenient way.
Improves Hydration, Many smoothies contain liquid ingredients like coconut water, orange juice, or milk, which can help improve hydration. This is particularly important during hot weather or after physical activities.

Coconut Water 🥥

Natural coconut water contains electrolytes and nutrients that aid in hydrating the body. It's a healthy alternative to commercially available sports drinks that often contain added sugars.

A fun fact about drinking Coconut Water that you may not be aware of

Coconut water is a natural source of electrolytes and essential nutrients for the body. Dancing coconut water can help replenish lost fluids and maintain optimal hydration.
Coconut water contains electrolytes such as potassium, sodium, magnesium, and calcium. Dancing coconut water can help restore electrolyte balance in the body after intense physical activity or fluid loss.
Coconut water contains several essential nutrients such as vitamin C, B-complex vitamins, enzymes, and amino acids. Dancing coconut water can provide additional nutrition to support overall health.

Thank you for reading this article on dev.to. I hope the information I've shared has been beneficial and provided new insights for you in the world of development. Feel free to leave comments or share this article with the dev.to community. See you in the next article!

Optimizing Logs Utilizing Logrus to Record Logs to a File

Suharxxxx — Wed, 14 Jun 2023 07:39:22 +0000

Logrus

is a logging library for Go programming language that simplifies the process of recording logs to a file. It offers a clean and intuitive API, making it easy to implement and customize logging functionalities according to your specific needs. With Logrus, you can improve the efficiency of your logs, making them more organized, informative, and easily manageable.



package main

import (
  "os"
  "github.com/sirupsen/logrus"
  "errors"
)

// Create a new instance of the logger. You can have any number of instances.
var log = logrus.New()

func init() {
  // Log as JSON instead of the default ASCII formatter.
  log.SetFormatter(&logrus.JSONFormatter{})
  // Only log the debug severity or above.
  log.SetLevel(logrus.DebugLevel)
}

func main() {
  ctx := "LogrusToLogFile" //context

  log.Out = os.Stdout
  // You could set this to any `io.Writer` such as a file
  file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
  if err == nil {
   log.Out = file
  } else {
    log.Info("Failed to log to file, using default stderr")
  }

  //make fake error
  err = errors.New("math: square root of negative number")
  if err != nil {
    log.WithFields(logrus.Fields{
      "ctx": ctx,
    }).Error("Write to file")
  }

}

In the given code, we use the Logrus library to log messages to a file, import the necessary packages such as.

"os" for system operations.
"github.com/sirupsen/logrus" for Logrus
"errors" to define an error.



import (
  "os"
  "github.com/sirupsen/logrus"
  "errors"
)

We create a new instance of the logger using logrus.New() Then, we set the log formatter to JSONFormatter to generate logs in JSON format. SetLevel is used to specify the logging level.



var log = logrus.New()

func init() {
  // Log as JSON instead of the default ASCII formatter.
  log.SetFormatter(&logrus.JSONFormatter{})
  // Only log the debug severity or above.
  log.SetLevel(logrus.DebugLevel)
}

which is set to debug level in this example.



 log.Out = os.Stdout
  // You could set this to any `io.Writer` such as a file
  file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
  if err == nil {
   log.Out = file
  } else {
    log.Info("Failed to log to file, using default stderr")
  }

In the main function, we perform several configurations for the logger.

we set logrus to log messages to os.Stdout as the default output. - we attempt to open the "logrus.log" file to log messages into it. - If successful, we set log.Out to use the file as the log output. - If there is an error, we print an informational message stating that logging to the file failed and fall back to using os.Stderr as the output.



os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)

Here's the breakdown of the arguments used in the OpenFile()

logrus.log is a string representing the file name that will be opened or created. In this example, the file name used is "logrus.log".
os.O_CREATE|os.O_WRONLY|os.O_APPEND is a combination of flags that determine the operations to be performed on the file.
- os.O_CREATE is used to create the file if it doesn't exist.
- os.O_WRONLY is used to open the file in write-only mode.
- os.O_APPEND is used to append data to the file if it already exists.
0666is the file mode that specifies the permissions for the created file. In this example, the mode 0666allows the user, group, and others to read and write the file.



//make fake error
  err = errors.New("math: square root of negative number")
  if err != nil {
    log.WithFields(logrus.Fields{
      "ctx": ctx,
    }).Error("Write to file")
  }

We create a fake error using errors.New(). If the error is not nil, we use logrus.WithFields to add additional information to the log, in this case, the "ctx" field. Then, we log an error message using logrus.Error/ Error("Write to file").

You will execute the command go run log_logrus.go to run a Go program called log_logrus.go. This program utilizes the Logrus library to record logs to a file.

By configuring Logrus to log messages to a file, we can record logs into the "logrus.log" file. This can be helpful for monitoring and analyzing application logs more efficiently.

Overall, the code is a simple example of using Logrus to log messages to a file with appropriate configurations and error handling.

In conclusion optimizing logs is crucial for efficient application development and maintenance. By utilizing Logrus, a powerful logging library for the Go programming language, you can simplify the process of recording logs to a file and enhance the effectiveness of your logging system.

https://github.com/sirupsen/logrus

Simplify Logging in Go Applications Configuration Logrus

Suharxxxx — Tue, 13 Jun 2023 04:13:19 +0000

Logrus

is a structured logger for Go (golang), completely API compatible with the standard library logger, popular logging library that provides extensive features and flexibility for logging in Go applications. logrus

First, we import the log package from logrus, which is the official Logrus package. Logrus is a popular logging library for Go that provides powerful features and flexibility.

package main

import (
  // "os"
  log "github.com/sirupsen/logrus"
)

In the code snippet, the log package is aliased as log from the logrus package. This allows you to use the Logrus library under the log namespace.

Example

The easiest approach to utilize Logrus is by utilizing the logger exported at the package level.

package main

import (
  log "github.com/sirupsen/logrus"
)

func main() {

  log.WithFields(log.Fields{
    "animal": "walrus",
  }).Info("A walrus appears")

}

The code snippet above demonstrates the usage of Logrus, a logging library in Go. In the function, we use the method to attach additional information to a log entry before printing it WithFields()

In this example, we create a log entry with the field set to . This field represents the type of animal that appears in the log entry.animal : walrus

Certainly! Here's a simplified explanation of the different error levels in Logrus :

Error: Used for critical errors in the application.
Warn: Used for non-critical warnings that require attention.
Info: Used for informative messages to track important events.
Debug: Used for debugging purposes during development.
Fatal: Used for fatal errors that cause the application to stop abruptly.

package main

import (
  log "github.com/sirupsen/logrus"
)

func main() {
  log.WithFields(log.Fields{
    "animal": "cat",
  }).Error("A walrus appears")

  log.WithFields(log.Fields{
    "animal": "fish",
  }).Debug("A walrus appears")

  log.WithFields(log.Fields{
    "animal": "walrus",
  }).Info("A walrus appears")

  log.WithFields(log.Fields{
    "animal": "dog",
  }).Warn("A walrus appears")

  log.WithFields(log.Fields{
    "animal": "pig",
  }).Fatal("A walrus appears")
}

func init() {
  // Log as JSON instead of the default ASCII formatter.
  log.SetFormatter(&log.JSONFormatter{})
  // Only log the warning severity or above.
  log.SetLevel(log.DebugLevel)
}

This code should be included in your application's initialization phase. It configures Logrus to use JSON formatting for log output and sets the log level to include debug messages.

Example with fake error.

package main

import (
  log "github.com/sirupsen/logrus"
  "errors"
)

func init() {
  // Log as JSON instead of the default ASCII formatter.
  log.SetFormatter(&log.JSONFormatter{})
  // Only log the debug severity or above.
  log.SetLevel(log.DebugLevel)
}

func main() {

  ctx := "TestLogrus" //context
  err := errors.New("math: square root of negative number")

  if err != nil {
    log.WithFields(log.Fields{
    "ctx": ctx,
    }).Error(err.Error())
  }

}

The code snippet provided demonstrates a basic implementation of Logrus in a Go application. Here's a simple explanation of what the code does:

An error variable err is created using the errors.New function. In this example, the error message states "math: square root of negative number".
The code checks if the error variable is not nil, indicating the occurrence of an error.
If an error exists, the Logrus WithFields function is used to add additional fields to the log entry. In this case, the ctx field is included with the value of the ctx variable.
Finally, the Error method is called on the Logrus logger to log the error message. The error message itself is retrieved using err.Error().

Additional

func init() {
  // Log as JSON instead of the default ASCII formatter.
  // log.SetFormatter(&log.JSONFormatter{})
  log.SetFormatter(&log.TextFormatter{
    DisableColors: false,
    FullTimestamp: true,
    ForceColors: true,
  })
  // Only log the warning severity or above.
  log.SetLevel(log.DebugLevel)
}

When a TTY is attached, otherwise just plain text

*https://github.com/sirupsen/logrus

Adding Context to Sentry for Simplified Issue Analysis

Suharxxxx — Wed, 28 Dec 2022 04:00:17 +0000

Context in Sentry

Refers to additional information that can be added to an error message or message sent to Sentry. Context usually contains information that is useful for analyzing and resolving issues in your application.

Examples of information that can be added as context include:

User information: Information about the user experiencing the issue.
Extra data: Additional data that is useful for analyzing the issue.

Context can be added to an error message or message using methods such as SetExtra, and SetUser in Sentry.



package main

import (
    "log"
    "time"
    "errors"
    "github.com/getsentry/sentry-go"
)

func main() {
    err := sentry.Init(sentry.ClientOptions{
        Dsn: "YOUR DSN",
        Debug: true,
    })
    if err != nil {
        log.Fatalf("sentry.Init: %s", err)
    }
    defer sentry.Flush(2 * time.Second)

    sentry.WithScope(func(scope *sentry.Scope) {

        // set context character
        scope.SetContext("character", map[string]interface{}{
            "name":        "Mighty Fighter",
            "age":         19,
            "attack_type": "melee",
        })

        //add extra data additional
        scope.SetExtra("extra_key", "extra_value")
        //set user id
        scope.SetUser(sentry.User{ID: "user_id_example"})
        //exemple error, fake err
        err = errors.New("Example Error 4")
        //capture error and level error
        scope.SetLevel(sentry.LevelError)
        sentry.CaptureException(err)
    })  
}

Some examples in implementation when sending to sentry.

Set context character information



// set context character
scope.SetContext("character", map[string]interface{}{
    "name":        "Mighty Fighter",
    "age":         19,
    "attack_type": "melee",
})

Set extra data additional



//add extra data additional
scope.SetExtra("extra_key", "extra_value")

Set user id



scope.SetUser(sentry.User{ID: "user_id_example"})

Learn more about context Sentry.
https://docs.sentry.io/platforms/go/enriching-events/context/
Learn more about conventions for common contexts in the contexts interface developer documentation.
https://develop.sentry.dev/sdk/event-payloads/contexts/

Convert date to easy read PHP

Suharxxxx — Mon, 26 Dec 2022 06:29:55 +0000

https://www.tehplayground.com/IjqAmFSaY1eS2y9Q

Set Level Error Sentry Golang

Suharxxxx — Sat, 24 Dec 2022 08:44:42 +0000

https://sentry.io/welcome/
Track errors & monitor performance in all major languages & frameworks with Sentry

The scope can include information about the environment in which the error occurred, the user who experienced the error, and any additional context that might be relevant to understanding and debugging the error.

https://docs.sentry.io/platforms/go/enriching-events/scopes/#whats-a-scope-whats-a-hub
information about Scope Sentry

A level Error could refer to a variety of issues in programming, depending on the context. It could be a syntax error, meaning there is a problem with the way the code is written and the interpreter or compiler cannot understand it.