DEV Community: Michael Fomenko

How to debug a problem you can not reproduce

Michael Fomenko — Thu, 19 May 2022 21:17:50 +0000

Sometimes, I get a bug that I just can't reproduce in the local environment. Still, this bug is very much present in the testing environment (dev or staging).
If I can't reproduce - I can't write a good test to cover this case.
And from this point on, a bug fixing is just one commit after another with a message "bug fix #".
Each time you need to wait for CI/CD pipeline, and after a few tries your workday is pretty much over :(

Everybody who was in this situation knows just how frustrating it might be.
I remember how I spent 2-3 hours comparing environments only to realize that there's a bug that represents only on docker-container-specific JVM.
But what if you could debug code not on your local machine, but remotely?
It appears that you actually can!

Let's take a look at how to do it with Java.

It's not that difficult.
In the script where you launch your Java app, you need to pass special parameters.

-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005

So now your launch command will look something like this:

java -jar -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 app.jar

You might want to change :5005 to the port of your choice. This is a port on which debug socket will be exposed.

WARNING! This parameter must not be used in production. Remote debug allows remote code execution.

Now you can use your IDE to attach a debugger to your remote running application. You just need to do the last step - add debug configuration.

You can do that in the Run/Debug Configurations menu. Choose Remote JVM Debug and set host that your application is running on & debug socket port.

That's it. Now you can debug code on the staging environment as it was running locally.

Conclusion

I highly encourage you to research this topic for a language of your choice, as this ability might save you a lot of time. You can use this to debug not only the app that is running on a different machine but also that is running in Docker locally.

Here are some resources I found for you:

More on Java remote debugging:
JetBrains tutorial
DZone article

Python: JetBrains tutorial
C#: MS Docs
JavaScript: JetBrains tutorial

Check out Spring Undo ↩️ v0.0.1!

Michael Fomenko — Wed, 18 May 2022 16:21:09 +0000

I just published Spring Undo v0.0.1

The library is still in development, but you can already try it out, all basic functionality works.
Just don't use it for production yet :)

GitHub: https://github.com/michaelfmnk/spring-undo

Spring Undo is a spring boot starter that provides a way to easily implement undo functionality in your Spring Boot application.

The main features are:

It drastically simplifies undo implementation. Reduces boilerplate that otherwise you need to manage.
It supports application scaling. Persist-module can use shared storage between all instances of your application. So you can call undo from any instance.
Spring-Undo is a Spring Boot Starter. You don't need to write any additional configuration for setting up Spring-Undo.

Usage

Add the following dependencies in your build.gradle file:

implementation 'dev.fomenko:spring-undo-core:v0.0.1'
implementation 'dev.fomenko:spring-undo-redis:v0.0.1'

or pom.xml file:

<dependency>
    <groupId>dev.fomenko</groupId>
    <artifactId>spring-undo-core</artifactId>
    <version>0.0.1</version>
</dependency>
<dependency>
    <groupId>dev.fomenko</groupId>
    <artifactId>spring-undo-redis</artifactId>
    <version>0.0.1</version>
</dependency>

For spring-undo-redis you need to have redis up & configured in your application.

First thing - you create a simple DTO that represents an event that can be undone.

@Data
@NoArgsConstructor
@AllArgsConstructor
public class EmailChangedEvent {
    private String oldEmail;
    private String newEmail;
}

Then register an event listener that will be called when either undo timeout is reached, or undo is called.

@Component
public class EmailChangedUndoEventListener extends UndoEventListener<EmailChangedEvent> {
    @Override
    public void onUndo(EmailChangedEvent action) {
        // handle here undo logic: reset db state
    }

    @Override
    public void onPersist(EmailChangedEvent action) {
        // handle here what to do when event is persisted
        // For example, you can send notification to the new & old email address
    }
}

Now autowire Undo bean and publish any object that represents an undoable action. publish returns an identifier of the action. You can use it to cancel action.

@RestController
@RequiredArgsConstructor
class UserController {
    private final Undo undo;

    @PutMapping("/email")
    public String changeEmail(ChangeEmailRequest request) {
        // main application logic
        var undoableEvent = new EmailChangedEvent("oldEmail@gmail.com", "newEmail@gmail.com");

        // publish method returns event id that can be used to undo the action
        return undo.publish(undoableEvent);
    }
}

And lastly, create a controller that will undo the action by its identifier.

@RestController
public class UndoController {
    private final Undo undo;

    @GetMapping("/undo/{id}")
    public String undo(@PathVariable String id) {
        undo.undo(id);
        return "Undo successful";
    }
}

You're done! 🎉

That's it. Now each time you want to implement an undo, you just create DTO event object & implement listener that will be called by Spring Undo on one of two cases: (1) undo was called, (2) timeout ended & undo was not called.

Contacts

Message me if you have any questions, suggestions or ideas for collaboration: michael@fomenko.dev

HttpStatusDogs is published! 🐶

Michael Fomenko — Sat, 14 May 2022 14:08:24 +0000

A few years back I wrote a simple Spring Boot starter that adds a header to your HTTP responses with a link to the appropriate HTTP status dog. The pet project (pun intended) was inspired by Mike Lee's project httpstatusdogs.com

Today I released it on Maven Central! 🥳

Usage

You can start using it just by adding it to your dependency list like this for Gradle:

implementation 'dev.fomenko:httpstatusdogs:1.0.0'

or for Maven:

<dependency>
    <groupId>dev.fomenko</groupId>
    <artifactId>httpstatusdogs</artifactId>
    <version>1.0.0</version>
 </dependency>

So now, for any endpoint, you'll have a HttpStatusDog header.

Example

Here's an example of a Spring controller

  @RestControllerclass FakeController {
         @GetMapping("/404")
         public String method404(HttpServletResponse response) {
              response.setStatus(404);
              return "Test";
         }
  }

and the response it provides:

HTTP/1.1 404 
StatusDog: https://httpstatusdogs.com/img/404.jpg
Content-Type: text/plain;charset=UTF-8
Content-Length: 5
Date: Fri, 13 May 2022 20:42:44 GMT

Test

You can find the code on my GitHub: https://github.com/michaelfmnkhttpstatusdogs
Maven Central: https://search.maven.org/artifact/dev.fomenko/httpstatusdogs/1.0.0/jar

P.S: For me, this lib is an attempt at releasing my own library. I'm planning on releasing my other projects soon.

Developing Send-To-Kindle Telegram Bot

Michael Fomenko — Sat, 14 May 2022 14:05:24 +0000

Lately, I've been using the Kindle app on my tablet a lot and it was always a hustle to send my e-books to my tablet. You need to convert to a proper format, transfer it somehow... meh...

So I decided to create a Telegram bot that does all this for you. You send it a book - it appears on your Kindle. Any format supported. That's it - that simple!

I decided to use Go as a language because I wanted to practice it more.

Programmatically converting books to .mobi

It was the main challenge. I did not want to code a converter myself so I started googling other ways to do it. Also, I decided not to go with some online conversion tools with an API as I did not want to rely on them.
So after a while, I stumbled upon the fact that Calibre - popular software for managing e-books - has CLI tools. They had everything, that's perfect!

So I started coding.
The conversion itself looks like this. A simple method that accepts input and output paths for an e-book and passes them to the ebook-convert CLI Tool.

func convert(in, out string) error {
    cmd := exec.Command("ebook-convert", in, out)
    if err := cmd.Run(); err != nil {
        return err
    }
    if err := cmd.Wait(); err != nil {
        return err
    }
    if _, err := os.Stat(out); errors.Is(err, os.ErrNotExist) {
        return errConversion
    }
    return nil
}

Telegram integration

Up next was telegram integration. That's easy.

Created bot credentials using BotFather
For integration with Telegram, I found a bot framework for Go - Telebot
The setup was pretty easy:

func (b *SendToKindleBot) Start() error {
    bot, err := tb.NewBot(tb.Settings{
        Token:  b.Token,
        Poller: &tb.LongPoller{Timeout: 10 * time.Second},
    })
    if err != nil {
        return ErrStartup
    }
    bot.Start()
    return nil
}

Sending via email

I created an email that my bot would use to send e-books.
Then don't forget to add it to Approved Personal Document Email List in your kindle settings.

And the method itself is pretty simple:

func (b *SendToKindleBot) sendFileViaEmail(path string) error {
    msg := email.NewMessage("", "")
    msg.From = mail.Address{Name: "From", Address: b.EmailFrom}
    msg.To = []string{b.EmailTo}

    if err := msg.Attach(path); err != nil {
        return err
    }

    auth := smtp.PlainAuth("", b.EmailFrom, b.Password, b.SMTPHost)
    addr := fmt.Sprintf("%s:%s", b.SMTPHost, b.SMTPPort)
    if err := email.Send(addr, auth, msg); err != nil {
        return err
    }
    return nil
}

Putting things together

So next I wrote all the insides of the telegram bot with the main thing being - a handler that would receive a file and send it to my kindle.

func (b *SendToKindleBot) documentHandler(bot *tb.Bot) func(msg *tb.Message) {
    return func(msg *tb.Message) {
        doc := msg.Document
        nameParts := strings.Split(doc.FileName, ".")
        fileNameWithoutExtension := strings.Join(nameParts[:len(nameParts)-1], "")
        extension := nameParts[len(nameParts)-1]

        originalFilePath := tmpFilesPath + doc.FileName
        if err := bot.Download(&doc.File, originalFilePath); err != nil {
            log.Println("could not download file", err)
            respond(bot, msg, "Sorry. I could not download file")
        }
        defer removeSilently(originalFilePath)

        fileToSend := originalFilePath
        if needToConvert(extension) {
            outputFilePath := tmpFilesPath + fileNameWithoutExtension + ".mobi"
            if err := convert(originalFilePath, outputFilePath); err != nil {
                log.Println("could not convert file", err)
                respond(bot, msg, "Sorry. I could not convert file")
            }
            fileToSend = outputFilePath
            defer removeSilently(outputFilePath)
        }

        if err := b.sendFileViaEmail(fileToSend); err != nil {
            log.Println("could not send file", err)
            respond(bot, msg, "Sorry. I could not send file")
        }
    }
}

And registered it in the bot:

...
bot.Handle(tb.OnDocument, b.documentHandler(bot))
...

Creating docker container

I wanted to put this app inside a docker container so I can deploy it easily in DigitalOcean and have it running 24/7.
This came to be a bit tricky. Installation of Calibre Tools was not straightforward. Still, after lots of tries, I came up with the following Dockerfile:

FROM amd64/ubuntu
COPY --from=golang:1.16.11-bullseye /usr/local/go/ /usr/local/go/
ENV PATH="/usr/local/go/bin:${PATH}"

RUN go env -w GOPROXY=direct GOFLAGS="-insecure"
ENV TZ=Europe/Minsk
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
RUN apt-get update && \
    apt-get upgrade -y && \
    apt-get install -y git && \
    apt-get install wget && \
    apt-get install -y python
RUN apt-get install -y ffmpeg libsm6 libxext6
RUN wget -nv -O- https://download.calibre-ebook.com/linux-installer.sh | sh /dev/stdin
RUN mkdir -p files
WORKDIR /app

COPY . .

RUN go build

RUN chmod +x ./send-to-kindle-telegram-bot
CMD ["./send-to-kindle-telegram-bot"]

Conclusion

After a lot of testing, I finally got the app up and running on DigitalOcean.

Hope you find this bot useful!
Full code you can find on my GitHub: https://github.com/michaelfmnk/send-to-kindle-telegram-bot
I'm open to any suggestions, ideas, or collaboration :)