DEV Community: Eduardo Hitek

Enabling Logs Query in Mongodb using Go

Eduardo Hitek — Sat, 02 Sep 2023 12:33:00 +0000

One way to debug an application is through logs. They can be used to identify issues, understand the execution flow, and also monitor the application's behavior. Among their types, database query logs are very useful for understanding what is happening with queries and other write operations. In this post, I will show how to enable MongoDB query logs in the official Go driver.

By default, logs in the official MongoDB driver for Go are disabled. To enable them, you just need to implement your own CommandMonitor and set it in the ClientOptions configuration.

Whenever I work with database connections, I like to create a struct that holds the necessary connection information. In this case, I'll create a struct called MongoConfig.

type MongoConfig struct {
    URL       string       // MongoDB connection URL
    AppName   string       // Application name
    DebugMode bool         // Flag to enable debug logs
    Log       slog.Logger  // Logger to be used
}

After that, I implement a createMongoClient function that takes this configuration struct and returns a *mongo.Client. The advantage of passing configurations via a struct is that if you want to add other parameters like ConnectionTimeout or MaxPoolSize, for example, you don't need to change the function's signature.

func createMongoClient(cfg MongoConfig) (*mongo.Client, error) {
    clientOptions := options.Client().ApplyURI(cfg.URL)
    clientOptions.SetAppName(cfg.AppName)

    if cfg.DebugMode { // Verifico se a flag de debug está habilitada
        monitor := &event.CommandMonitor{
            Started: func(_ context.Context, e *event.CommandStartedEvent) {
                if e.CommandName != "endSessions" { // Ignoro os comandos de finalização de sessão
                    cfg.Log.Info(e.Command.String())
                }
            },
        }

        clientOptions.SetMonitor(monitor)
    }

    client, err := mongo.Connect(context.Background(), clientOptions)
    if err != nil {
        return nil, err
    }

    return client, nil
}

Afterward, I use the function to create the MongoDB client and perform operations in my application.

mongoCfg := MongoConfig{
        URL:       "mongodb://localhost:27017",
        AppName:   "MongoDB with query log",
        DebugMode: true,
        Log:       *slog.Default(),
    }

    client, err := createMongoClient(mongoCfg)
    if err != nil {
        log.Fatal(err)
    }

Examples of logs for some operations:

PING
2023/09/02 08:48:09 INFO {"ping": {"$numberInt":"1"},"lsid": {"id": {"$binary":{"base64":"HBu0mDZaRHaNx0TPpBcaeg==","subType":"04"}}},"$db": "admin"}

INSERT
2023/09/02 09:04:43 INFO {"insert": "users","ordered": true,"lsid": {"id": {"$binary":{"base64":"ZIZW5N5OR+ympGFggFu6uA==","subType":"04"}}},"$db": "example-mongo","documents": [{"_id": {"$oid":"64f324db99a1dac5fdc37251"},"name": "Eduardo","alias": "eduardohitek","site": "https://eduardohitek.dev"}]}

FIND
2023/09/02 09:05:59 INFO {"find": "users","filter": {"alias": "eduardohitek"},"lsid": {"id": {"$binary":{"base64":"+ji9+sJIRVC0HsawBmTAPw==","subType":"04"}}},"$db": "example-mongo"}

Here is a gist with the code used in the post.

List of apps I use every day - Version 2023

Eduardo Hitek — Tue, 20 Jun 2023 17:23:00 +0000

I enjoy reading posts about the tools/apps people use in their daily lives, whether for work or personal use. I always end up discovering new tools or functionalities that I wasn't aware of. That's why I decided to create a post about the apps I use every day. The idea is to update this post every year to see how things change.

iTerm2: It has been my terminal of choice for macOS for years and continues to serve me well to this day. However, I have been following the development of Rio, an alternative being developed by @raphamorims.
fish: A very fast shell with various customization options to streamline daily commands. I discovered it through this post by @caarlos0, where he provides more details about performance and the differences between fish and zsh. Additionally, I use some CLI utilities like delta, exa, and ripgrep. Here's my dotfiles for fish.
Arc: The new favorite when it comes to browsers. It has a contextual tab organization feature based on your usage, which helps separate work-related and personal items. It's worth taking a look. If you need an invitation, just let me know.
Shottr: A tool for taking screenshots and sharing them with others. It offers more functionality than the native macOS tool and is much lighter than Skitch.
Rectangle: A handy tool for organizing windows on macOS. In my case, as I use two monitors, it's very helpful when I need to move apps from one screen to another or when I want to arrange windows side by side. It offers various shortcut options and configurations to suit your window management needs.
Alfred: A well-known replacement for the native Spotlight. It's a productivity tool that I use to open apps, search for files, execute commands, etc. The free version is already quite useful, but the paid version brings more functionality and integrations with other apps.
CopyClip: A lifesaver with clipboard history. I use it a lot for copying and pasting texts that I need to use in multiple places. You can define how many items you want it to store in the history and set shortcuts for frequently used items.
Cron: An alternative to the native macOS calendar application. It has a cleaner and simpler interface to use. There is also an iOS version that syncs with macOS.
Notion: A well-known tool responsible for various courses on Udemy :) I use it to organize my studies, take notes and create my bragdoc.
Zed: A text editor that I am currently testing and using to write this post. It provides a more minimalist and clean approach without relying on many extensions, with built-in features such as Github Copilot, LSP, and live collaboration.

View original post

Highlights in a Technical Interview for Junior Candidates

Eduardo Hitek — Thu, 15 Jun 2023 07:11:00 +0000

Highlights in a Technical Interview for Junior Candidates

Recently, someone who is seeking their first opportunity in the development field asked me for advice on what to study or what certifications to obtain to stand out in a job interview. I didn't respond immediately and took some time to think, as the landscape has changed significantly since I was a Junior Developer.

So, I came up with a list of 7 topics that I believe make a difference for someone at this professional stage and would catch my attention during an interview process.

Disclaimer: The idea is not for the person to delve deep and become an expert in these items; that can happen later with work experience. The intention is to have a basic understanding and be able to discuss the topics in an interview.

Docker: It's quite rare to have no contact with container solutions in the field, so it's interesting to have an understanding of what Docker is, how to create, run, stop, and check logs of a locally running Docker container.
Git: After surviving CVS and SVN, I don't see any other version control solution taking over Git in our day-to-day work. Therefore, understanding concepts like branches, merge vs. rebase, and how to recover from errors is a differentiating factor.
CI/CD: Here, it's not about knowing how to set up a workflow in Github Actions, but rather understanding the meanings of the acronyms CI/CD and the value they bring to the quality of the final code and time saved through automation.
Testing: Even if you haven't gone beyond unit or integration testing, it's good to have an understanding of other types of tests and in which scenarios they are important.
Databases: Many people only get the chance to work with relational databases (MySQL or Postgres), so it's interesting to explore NoSQL solutions (MongoDB, Cassandra, etc.). It's a plus to know in which scenarios each approach can be more suitable.
Agile Methodologies: Most likely, you will join a team that uses a variant of Scrum or Kanban (or perhaps both), so it's valuable to already know how they work and understand the rituals of these methodologies.
REST API Patterns: Whether working on the front-end or back-end, there's a high chance that you'll be involved in synchronous communication using REST APIs. It's worthwhile to understand the methods, URL best practices, code best practices, error messages, and more.

As I mentioned earlier, the intention is not for you to become an expert in the items above, nor to know them all. However, I guarantee that having a basic understanding can make a considerable difference during a technical interview.

Do you agree with the points above? Please leave a comment with your thoughts or if you believe any items are missing from this list.

View original post

Performing Benchmark Tests in Go

Eduardo Hitek — Sun, 01 Aug 2021 00:13:21 +0000

Benchmark testing in programming is the act of efficiently comparing performance between algorithms in order to choose which approach to follow in certain scenarios. We can also apply when deciding which external libraries or frameworks to use, in addition to evaluating if any refactoring will bring harm to our code.

The Go language already has tools for these types of tests by default, making the experience more user-friendly and without the need for external tools.

Let's see how to verify this in practice.

Analyzing Palindromic Verification Performance

Palindrome is a word or group of words that have linear symmetry, that is, they remain the same when read backwards. A more common example is the word level or anna where the reading order does not change the meaning of the word. We can also obtain this effect by combining a few words, forming simple sentences like: never odd or even.

It is quite common in job interviews that you are faced with the challenge of writing an algorithm to check whether a phrase or word is palindrome or not.

For examples I used 3 different algorithms to analyze which will have the best performance:

1) PalindromeReverse: receives a string, reverses it and checks if the 2 strings are equal.

func reverse(s string) string {
   runes := []rune(s)
   for i, j := 0, len(runes)-1; i<j; i, j = i+1, j-1 {
       runes[i], runes[j] = runes[j], runes[i]
   }
   return string(runes)
}

func palindromeReverse(str string) bool {
   strReversed := reverse(str)
   return strReversed == str
}

2) PalindromeFromEnd: cycles through the string comparing the 1st word with the last and so on.

func palindromeFromEnd(str string) bool {
   runes := []rune(str)
   length := len(runes)
   for i := 0; i < length; i++ {
       if runes[i] != runes[length-1-i] {
           return false
       }
   }
   return true
}

1) palindromeFromMiddle: runs from the middle characters to the beginning/end of the string.

func palindromeFromMiddle(str string) bool {
   runes := []rune(str)
   length := len(runes)
   middleI, middleJ := (length/2)-1, (length/2)+1
   if length%2 == 0 {
       middleJ -= 1
   }

   for i, j := middleI, middleJ; i >= 0; i, j = i-1, j+1 {
       if runes[i] != runes[j] {
           return false
       }
   }
   return true
}

With the functions created, now we need to write the Benchmark Tests functions.

Benchmark Tests

In our example, let's create the test file main_test.go and within it create the following test functions:

func BenchmarkPalindromeFromMiddle_Banana(b *testing.B) {
   for n := 0; n<b.N; n++ {
       palindromeFromMiddle("banana")
   }
}
func BenchmarkPalindromeReverse_Banana(b *testing.B) {
   for n := 0; n<b.N; n++ {
       palindromeReverse("banana")
   }
}
func BenchmarkPalindromeFromEnd_Banana(b *testing.B) {
   for n := 0; n<b.N; n++ {
       palindromeFromEnd("banana")
   }
}

Here we are asking Go to run each of the functions with the banana string. Next step is to run the following command in the terminal: go test -bench=. -benchtime=1s

~/dev/eduardohitek/go-benchmark-example main*
❯ go test -bench=. -benchtime=1s
goos: darwin
goarch: amd64
pkg: github.com/eduardohitek/go-benchmark-example
cpu: Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz
BenchmarkPalindromeFromMiddle_Banana-12 69054604 16.36 ns/op
BenchmarkPalindromeReverse_Banana-12 16145308 69.83 ns/op
BenchmarkPalindromeFromEnd_Banana-12 91725068 15.84 ns/op
PASS
ok github.com/eduardohitek/go-benchmark-example 4.563s

Following the argument we informed, each benchmark function is executed for 1 second and we have 2 pieces of information for each: Number of executions and average time of each execution. For this example of a non-palindromic word, and when the difference was between the 1st and the last letter, the BenchmarkPalindromeFromEnd_Banana was more performant because it had a lower average time per operation.

In the next example we use a word major palindrome (nomelgibsonisacasinosbiglemon):

~/dev/eduardohitek/go-benchmark-example main*
❯ go test -bench=. -benchtime=1s
goos: darwin
goarch: amd64
pkg: github.com/eduardohitek/go-benchmark-example
cpu: Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz
BenchmarkPalindromeFromMiddle_nomelgibsonisacasinosbiglemon-12 18193920 56.29 ns/op
BenchmarkPalindromeReverse_nomelgibsonisacasinosbiglemon-12 4255890 272.6 ns/op
BenchmarkPalindromeFromEnd_nomelgibsonisacasinosbiglemon-12 16961797 63.68 ns/op
PASS
ok github.com/eduardohitek/go-benchmark-example 5.078s

In this example the BenchmarkPalindromeFromMiddle came out ahead. The last test uses a much longer string (+800 characters) and we confirm which function does better in this scenario:

~/dev/eduardohitek/go-benchmark-example main*
❯ go test -bench=. -benchtime=1s
goos: darwin
goarch: amd64
pkg: github.com/eduardohitek/go-benchmark-example
cpu: Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz
BenchmarkPalindromeFromMiddle_longstring-12 672807 1774 ns/op
BenchmarkPalindromeReverse_longstring-12 141945 7784 ns/op
BenchmarkPalindromeFromEnd_longstring-12 524437 2121 ns/op
PASS
ok github.com/eduardohitek/go-benchmark-example 5.006s

So we could see how easy it is to perform this type of tests to assess the changes and performance of algorithms in Go applications.

All source code for the examples is found here.

Originally posted on my website

Installing Portainer for managing Docker instances

Eduardo Hitek — Sat, 17 Jul 2021 13:50:32 +0000

Portainer is an Open Source application for managing Docker on local machines or servers.
Through its graphical interface it is possible to view and edit your Containers, Images, Volumes and so on. And its installation is very easy as it is distributed as a Docker image.

Just perform the following steps:

1) Create a volume to persist your settings:

docker volume create portainer_data

1) Run the docker command to create the container and inform some initial configuration parameters:

docker run -d -p 9000:9000 --name=portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce

With this command we are telling Docker to run this container in the background mode, export port 9000, set the name to portainer, set the restart policy to always restart and link the container volumes to local volumes on your machine.

After executing the command, just access http://localhost:9000 and set the admin password.

The next step is to point which environment you want to manage, in my case I will select the local docker instance.

And that's it, you'll have the lists of active containers, their status and possible available actions.

Microservices: HTTP Requests vs Messaging

Eduardo Hitek — Tue, 18 Jun 2019 19:57:49 +0000

I'm currently designing a solution using Microservices and saw both implementations (HTTP Requests and Messaging) for communication between them. Considering that theses microservices will run on the same network, in what scenarios do you recommend each one of them?

MongoDB Golang Driver Tutorial

Eduardo Hitek — Sun, 16 Jun 2019 16:26:05 +0000

After years relying on Community drivers like mgo and globalsign/mgo, last year MongoDB announced they were building it’s own solution. Last March they released the version 1.0.0, so let’s see how to make some normal operations using the Oficial driver.

First of all, you need to download the driver using go get.

go.mongodb.org/mongo-driver/mongo

Assuming your MongoDB installation is using the default setting, your method should be like this:

package main

import (
    "context"
    "log"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/mongo/readpref"
)

func GetClient() *mongo.Client {
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
    client, err := mongo.NewClient(clientOptions)
    if err != nil {
        log.Fatal(err)
    }
    err = client.Connect(context.Background())
    if err != nil {
        log.Fatal(err)
    }
    return client
}

To test the connection to the mongo, we can call a function called Ping, and check if return any error. Otherwise, out connection was successful.

func main() {
    c := GetClient()
    err := c.Ping(context.Background(), readpref.Primary())
    if err != nil {
        log.Fatal("Couldn't connect to the database", err)
    } else {
        log.Println("Connected!")
    }
}

Now for the next examples I created a database called civilact and a collection heroes and add the followings documents:

{ 
    "_id" : ObjectId("5d0574824d9f7ff15e989171"), 
    "name" : "Tony Stark", 
    "alias" : "Iron Man", 
    "signed" : true
}
{ 
    "_id" : ObjectId("5d0574d74d9f7ff15e989172"), 
    "name" : "Steve Rodgers", 
    "alias" : "Captain America", 
    "signed" : false
}
{ 
    "_id" : ObjectId("5d0574e94d9f7ff15e989173"), 
    "name" : "Vision", 
    "alias" : "Vision", 
    "signed" : true
}
{ 
    "_id" : ObjectId("5d0575344d9f7ff15e989174"), 
    "name" : "Clint Barton", 
    "alias" : "Hawkeye", 
    "signed" : false
}

To work with these documents, would be better if we create a struct that represents all the Fields and their json names.

type Hero struct {
    Name   string `json:"name"`
    Alias  string `json:"alias"`
    Signed bool   `json:"signed"`
}

Now let's create a Method that will return all Heroes expecting 2 parameters: MongoDB Client and a bson.M that represents a filter. Is this filter is empty, the method will return all documents.

import (
    "context"
    "log"

    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "go.mongodb.org/mongo-driver/mongo/readpref"
)

func ReturnAllHeroes(client *mongo.Client, filter bson.M) []*Hero {
    var heroes []*Hero
    collection := client.Database("civilact").Collection("heroes")
    cur, err := collection.Find(context.TODO(), filter)
    if err != nil {
        log.Fatal("Error on Finding all the documents", err)
    }
    for cur.Next(context.TODO()) {
        var hero Hero
        err = cur.Decode(&hero)
        if err != nil {
            log.Fatal("Error on Decoding the document", err)
        }
        heroes = append(heroes, &hero)
    }
    return heroes
}

The breakdown is:

Create a collection that represents the collection in the database;
Ask the collection to return a cursor of with the elements based oh the filter (in this case the filter is empty, so will return all elements);
Iterate this cursor and Decode each document to a Hero type;
Append the Hero decoded in the heroes array.

If we run inside the main function, our return will be:

heroes := ReturnAllHeroes(c, bson.M{})
for _, hero := range heroes {
    log.Println(hero.Name, hero.Alias, hero.Signed)
}

2019/06/15 21:07:00 Tony Stark Iron Man true
2019/06/15 21:07:00 Steve Rodgers Captain America false
2019/06/15 21:07:00 Vision Vision true
2019/06/15 21:07:00 Clint Barton Hawkeye false

To retrieve just the Heroes whom signed the Sokovia Accords, we just need to change the filter.

heroes := ReturnAllHeroes(c, bson.M{"signed": true})

2019/06/15 21:18:04 Tony Stark Iron Man true
2019/06/15 21:18:04 Vision Vision true

To retrieve just one Hero, our new method will be like this:

func ReturnOneHero(client *mongo.Client, filter bson.M) Hero {
    var hero Hero
    collection := client.Database("civilact").Collection("heroes")
    documentReturned := collection.FindOne(context.TODO(), filter)
    documentReturned.Decode(&hero)
    return hero
}

The call will be:

    hero := ReturnOneHero(c, bson.M{"name": "Vision"})
    log.Println(hero.Name, hero.Alias, hero.Signed)

    2019/06/15 22:55:44 Vision Vision true

Now, to increase our collection of Heroes and insert, for example Doctor Strange: The new method will be like this:

func InsertNewHero(client *mongo.Client, hero Hero) interface{} {
    collection := client.Database("civilact").Collection("heroes")
    insertResult, err := collection.InsertOne(context.TODO(), hero)
    if err != nil {
        log.Fatalln("Error on inserting new Hero", err)
    }
    return insertResult.InsertedID
}

That's how we method will be used and checked by our previous method ReturnOneHero:

hero = Hero{Name: "Stephen Strange", Alias: "Doctor Strange", Signed: true}
insertedID := InsertNewHero(c, hero)
log.Println(insertedID)
hero = ReturnOneHero(c, bson.M{"alias": "Doctor Strange"})
log.Println(hero.Name, hero.Alias, hero.Signed)

Great! We added a Sorcerer Supreme in our Heroes collection, but what if he didn't like and asked us to remove him from it? Well, that's why we need a RemoveOneHero method.

func RemoveOneHero(client *mongo.Client, filter bson.M) int64 {
    collection := client.Database("civilact").Collection("heroes")
    deleteResult, err := collection.DeleteOne(context.TODO(), filter)
    if err != nil {
        log.Fatal("Error on deleting one Hero", err)
    }
    return deleteResult.DeletedCount
}

And that's how we check:

heroesRemoved := RemoveOneHero(c, bson.M{"alias": "Doctor Strange"})
log.Println("Heroes removed count:", heroesRemove
hero = ReturnOneHero(c, bson.M{"alias": "Doctor Strange"})
log.Println("Is Hero empty?", hero == Hero{ })

For last, let's imagine that Hawkeye changed his mind and now wants to sign the Accords. So let's make de UpdateHero method.

func UpdateHero(client *mongo.Client, updatedData bson.M, filter bson.M) int64 {
    collection := client.Database("civilact").Collection("heroes")
    atualizacao := bson.D{ {Key: "$set", Value: updatedData} }
    updatedResult, err := collection.UpdateOne(context.TODO(), filter, atualizacao)
    if err != nil {
        log.Fatal("Error on updating one Hero", err)
    }
    return updatedResult.ModifiedCount
}

That's it! The regular CRUD Operation was covered and our Heroes can decide their fate.
All the code for these examples is available here and this tutorial was also posted at my blog. Here is the Driver's oficial repo and oficial docs

Feel free to get in touch for any question, suggestion or mistake that i made.