Forem: Rafa Mori

🚀 LookAtni File Markers — Invisible Markers to Structure Your Files Like Magic

Rafa Mori — Sun, 13 Jul 2025 04:33:32 +0000

Have you ever needed to extract specific parts of code to create a tutorial, technical documentation, or even educational content?

What if you could do this by marking directly in the file itself, without breaking your workflow, and even automate the extraction?

Allow me to introduce LookAtni File Markers — a VSCode extension that gives you superpowers using just comments!

🧠 How it works

You mark blocks using a simple, visual syntax:

//␜/ docs/start.md /␜//

The extension recognizes this as a “visual marker.” It lets you:

Navigate through these points as if they were anchors in VSCode
Extract the marked blocks to external files
Validate, reorder, synchronize… all automatically

📸 See it in action

🧰 Use cases

📘 Technical documentation — extract snippets directly from code to keep examples always updated
👨‍🏫 Educational content — assemble lessons, tutorials, and PDF materials from live code
✅ Code reviews — mark crucial points for reviewers
⚙️ CI/CD pipelines — use markers to generate temporary files or validate structure

🔧 Built-in CLI (coming soon)

lookatni extract src/
lookatni validate

Perfect for integration with GitHub Actions or build pipelines.

📦 Install now

Get it from the VSCode Marketplace or via the Command Palette:

ext install rafa-mori.lookatni-file-markers

❤️ Open Source

This project is fully open source:
https://github.com/rafa-mori/lookatni-file-markers

If you enjoy it, please ⭐ the repo and share any feedback—you’re more than welcome!

Create living structure within your files.
Mark. Extract. Automate.

🚀 LookAtni File Markers — Marcadores invisíveis para estruturar seus arquivos como mágica

Rafa Mori — Sun, 13 Jul 2025 04:26:50 +0000

Já precisou extrair partes específicas de um código para criar um tutorial, uma documentação técnica ou até um conteúdo didático?

E se você pudesse fazer isso marcando diretamente no próprio arquivo, sem quebrar o fluxo de trabalho, e ainda automatizar a extração?

Apresento o LookAtni File Markers — uma extensão do VSCode que te dá superpoderes usando apenas comentários!

🧠 Como funciona?

Você marca blocos com uma sintaxe simples e visual:

//␜/ docs/inicio.md /␜//

E a extensão reconhece isso como um “marcador visual”.
Ela permite:

Navegar por esses pontos como se fossem âncoras no VSCode
Extrair os blocos marcados para arquivos externos
Validar, reordenar, sincronizar… tudo automaticamente

📸 Veja em ação

🧰 Casos de uso

📘 Documentação técnica — extraia trechos direto do código para manter exemplos sempre atualizados
👨‍🏫 Conteúdo educacional — monte aulas, tutoriais e PDFs com base em código vivo
✅ Revisões de código — marque pontos importantes para revisores
⚙️ CI/CD pipelines — use markers para gerar arquivos temporários ou validar estrutura

🔧 CLI embutido (em breve)

bash lookatni extract src/ lookatni validate

Ideal pra integrar com GitHub Actions ou ferramentas de build.

📦 Instale agora

Acesse o Marketplace do VSCode ou via Command Palette:

bash ext install rafa-mori.lookatni-file-markers

❤️ Open Source

O projeto é totalmente open source:
https://github.com/rafa-mori/lookatni-file-markers

Se você curtir, ⭐️ no repositório e feedbacks são mais que bem-vindos!

Crie uma estrutura viva dentro dos seus arquivos.
Marque. Extraia. Automatize.

🚀 Ollama Dev Stack: WebUI + Benchmark + Docker + Fallback (Open Source)

Rafa Mori — Fri, 20 Jun 2025 17:45:09 +0000

Um ambiente local completo para rodar LLMs como `deepseek-coder` e `mistral` com Docker, Open-WebUI, benchmarks automáticos, fallback inteligente e uma DX otimizada via Makefile ou script Bash — tudo open source, tudo fácil de estender!

🧠 Por que criei isso?

Eu queria um ambiente de IA local que fosse:

💡 Simples de iniciar (make dev ou setup-dev.sh)
🔁 Resiliente (reinicia containers com falha automaticamente)
🧪 Benchmarkado (testa o tempo de resposta logo após subir)
🐳 Totalmente Dockerizado
🤖 Rodando modelos como DeepSeek Coder e Mistral direto no meu PC
🧰 Personalizável para qualquer outro uso com LLMs offline

Então eu criei o mori-ollama-srv.

🔧 O que tem no stack?

✅ Ollama com suporte a modelos como deepseek-coder:6.7b, mistral, llama
✅ Open-WebUI (interface para chats)
✅ Benchmarks automáticos via script
✅ Docker Compose + Makefile para facilitar tudo
✅ Ativação de modo “performance” na CPU (Linux)
✅ Execução local ou remota via SSH

🧪 Exemplos de uso

# Rodar com modelo padrão (deepseek)
make dev

# Rodar com modelo leve (mistral)
make install ARGS="--light"

# Pular benchmark
make install ARGS="--no-benchmark"

# Rodar tudo remotamente
make install ARGS="--remote=me@192.168.100.10"

🌍 Acesse o WebUI

Depois de subir tudo, o painel estará acessível em:

👉 http://localhost:3000

📁 Repositório e Gist

📄 Licença

MIT © Rafael Mori
Contribuições são super bem-vindas 🙌

Se curtir, deixa uma estrela ⭐ lá no GitHub e comenta aqui como pretende usar!

TimeCraft: Simplifying Time Series Analysis and Automation

Rafa Mori — Fri, 16 May 2025 06:01:55 +0000

Today is one of those days when I'm really excited! I've just launched TimeCraft, a tool written in Python that integrates time series analysis, database connections, and task automation into a single package. If you're looking for agility and flexibility for your data projects, come and see what I've created!

Why TimeCraft?

During recent projects, I realized that integrating forecasting models, querying databases, and automating workflows could become a challenge – especially if each of these functions were isolated in different tools. That's when TimeCraft was born: to simplify complex tasks and provide an integrated experience, without sacrificing robustness and good programming practices.

Main Features

TimeCraft was developed with a focus on:

Time Series Analysis: Robust scripts for modeling, forecasting, and evaluating temporal data. Ideal for projecting trends and anticipating changes in various areas, such as finance, logistics and much more.
Database Integration: Efficient tools for connecting, consulting and extracting information from various database systems.
Automation & Notifications: Automate your processes and receive alerts via webhooks – perfect for integrating with platforms such as Slack or Discord, keeping your team always up to date.

Check out the project structure:

timecraft/
├── /src/ # Core logic and modules
├── /docs/ # Documentation (README, INSTALL, CONTRIBUTING)
├── /tutorials/ # Practical guides and advanced use cases
├── /data/ # Example datasets and generated results
├── /assets/ # Visual content for dissemination
├── /venv/ # Virtual environment and dependency management
└── requirements.txt # Python dependencies

Usage Examples

Scheduling Executions

TimeCraft allows you to schedule model execution, similar to cronjob, but integrated with your Python environment. For example, to run a model every 10 minutes, just use:

python -m timecraft_ai schedule 600 timecraft

Or, directly in your code:

from timecraft_ai import TimeCraftAI, run_scheduled

tc = TimeCraftAI()
model = tc.create_timecraft_model(
data="data/hist_cambio_float.csv",
date_column="dt",
value_columns=["purchaseValue", "saleValue"],
is_csv=True
)
run_scheduled(model.run, interval_seconds=600) # Runs every 10 minutes

Notifications via Webhook

One of the most interesting features is the native integration with notifications via webhooks. So, when you finish an analysis or training your model, a notification is sent to the platform of your choice, be it Slack, Discord or a custom endpoint:

model.run(
webhook_url="https://hooks.slack.com/services/XXX/YYY/ZZZ",
webhook_payload_extra={"text": "TimeCraft model finished!"}
)

This flexibility allows you to keep your workflow monitored and integrated, without additional effort.

Exploring New Possibilities

In addition to the immediate uses presented in the documentation, TimeCraft can be transformed into a base for even more functionalities:

Integration with Dashboards: Create an optional module to visualize the results in real time using frameworks such as Dash or Streamlit. Imagine monitoring your models with interactive and dynamic graphs! - Cloud Data Source Support: Extend the reach of TimeCraft by connecting to services like BigQuery and Snowflake. This would allow you to analyze large volumes of data without compromising performance.
Machine Learning Pipeline: Use TimeCraft in conjunction with popular machine learning libraries (like scikit-learn or TensorFlow) to build complete pipelines, from collection and preprocessing to evaluation of advanced models (ARIMA, Prophet, LSTM).
Advanced Notifications: Continue exploring integrations, for example, implementing email or SMS notifications, as well as richer interactions with third-party APIs.
Event-Based Automation: Combine scheduling with real-time monitoring to create triggers that execute analyses when certain events occur, taking automation to the next level.

Final Thoughts

TimeCraft is a realization that merges data analysis, automation and integration into a single tool, and was designed to make the work of developers and data scientists easier. Whether you are a professional who needs to automate processes, make predictions or just explore new ways to integrate multiple technologies, TimeCraft has something to offer.

If you are interested in collaborating, experimenting or suggesting new features, feel free to access the repository, contribuit with ideas and be part of this journey!

Next Steps

Experimentation: Test the modules, analyze the results and discover how TimeCraft can fit into your workflows.
Feedback & Contributions: The community is essential to make this project even bigger. Leave your feedback and share your experiences.
New Integrations: Explore integration with other tools, create dashboards and develop new features to expand the reach of this tool.

I'm excited to see how each of you will leverage this project in your daily solutions!

I hope these ideas inspire you to explore new ways to leverage TimeCraft. And if you have other perspectives or ideas for expanding this tool, share them in the comments – the exchange of experiences is what really drives innovation in the development world.

Happy coding and until next time!

TimeCraft: Simplificando Análise de Séries Temporais e Automação

Rafa Mori — Fri, 16 May 2025 05:56:52 +0000

Hoje é um daqueles dias em que a empolgação bate forte! Acabo de lançar o TimeCraft, uma ferramenta feita em Python que integra análise de séries temporais, conexão com bancos de dados e automação de tarefas num único pacote. Se você busca agilidade e flexibilidade para seus projetos de dados, venha conhecer o que criei!

Por Que TimeCraft?

Durante projetos recentes, percebi que integrar modelos de previsão, efetuar consultas em bancos de dados e automatizar fluxos de trabalho podia se tornar um desafio – especialmente se cada uma dessas funções estivesse isolada em ferramentas diferentes. Foi aí que o TimeCraft nasceu: para simplificar tarefas complexas e proporcionar uma experiência integrada, sem abrir mão da robustez e das boas práticas de programação.

Recursos Principais

O TimeCraft foi desenvolvido com foco em:

Análise de Séries Temporais: Scripts robustos para modelagem, previsão e avaliação de dados temporais. Ideal para projetar tendências e antecipar mudanças em diversas áreas, como finanças, logística e muito mais.
Integração com Bancos de Dados: Ferramentas eficientes para conectar, consultar e extrair informações de diversos sistemas de banco de dados.
Automação & Notificações: Automatize seus processos e receba alertas via webhooks – perfeito para integrar com plataformas como Slack ou Discord, mantendo sua equipe sempre atualizada.

Confira a estrutura do projeto:

timecraft/
├── /src/                # Lógica central e módulos
├── /docs/               # Documentação (README, INSTALL, CONTRIBUTING)
├── /tutorials/          # Guias práticos e casos avançados de uso
├── /data/               # Conjuntos de dados de exemplo e resultados gerados
├── /assets/             # Conteúdo visual para divulgação
├── /venv/               # Ambiente virtual e gerenciamento de dependências
└── requirements.txt     # Dependências em Python

Exemplos de Uso

Agendamento de Execuções

O TimeCraft permite que você agende a execução de modelos, algo semelhante ao cronjob, mas de forma integrada ao seu ambiente Python. Por exemplo, para rodar um modelo a cada 10 minutos, basta utilizar:

python -m timecraft_ai schedule 600 timecraft

Ou, diretamente em seu código:

from timecraft_ai import TimeCraftAI, run_scheduled

tc = TimeCraftAI()
model = tc.create_timecraft_model(
    data="data/hist_cambio_float.csv",
    date_column="dt",
    value_columns=["purchaseValue", "saleValue"],
    is_csv=True
)
run_scheduled(model.run, interval_seconds=600)  # Executa a cada 10 minutos

Notificações via Webhook

Uma das funcionalidades mais interessantes é a integração nativa com notificações via webhooks. Assim, ao finalizar uma análise ou o treinamento do seu modelo, uma notificação é enviada para a plataforma de sua escolha, seja Slack, Discord ou um endpoint personalizado:

model.run(
    webhook_url="https://hooks.slack.com/services/XXX/YYY/ZZZ",
    webhook_payload_extra={"text": "TimeCraft model finished!"}
)

Essa flexibilidade permite que você mantenha seu fluxo de trabalho monitorado e integrado, sem esforço adicional.

Explorando Novas Possibilidades

Além dos usos imediatos apresentados na documentação, o TimeCraft pode se transformar em uma base para ainda mais funcionalidades:

Integração com Dashboards: Crie um módulo opcional para visualização dos resultados em tempo real usando frameworks como Dash ou Streamlit. Imagine monitorar seus modelos com gráficos interativos e dinâmicos!
Suporte a Fontes de Dados na Nuvem: Amplie o alcance do TimeCraft conectando-se a serviços como BigQuery e Snowflake. Isso permitiria análises em grandes volumes de dados sem comprometer a performance.
Pipeline de Machine Learning: Utilize o TimeCraft em conjunto com bibliotecas populares de machine learning (como scikit-learn ou TensorFlow) para construir pipelines completos, desde a coleta e pré-processamento até a avaliação de modelos avançados (ARIMA, Prophet, LSTM).
Notificações Avançadas: Siga explorando integrações, por exemplo, implementando notificações por e-mail ou SMS, bem como interações mais ricas com APIs de terceiros.
Automação Baseada em Eventos: Combine o agendamento com monitoramento em tempo real para criar triggers que executem análises quando determinados eventos ocorrerem, elevando o nível da automação.

Considerações Finais

O TimeCraft é uma realização que funde análise de dados, automação e integração em uma única ferramenta, e foi pensado para facilitar o trabalho dos desenvolvedores e cientistas de dados. Seja você um profissional que precisa automatizar processos, fazer previsões ou apenas explorar novas formas de integrar múltiplas tecnologias, o TimeCraft tem algo a oferecer.

Se você tem interesse em colaborar, experimentar ou sugerir novas funcionalidades, fique à vontade para acessar o repositório, contribuir com ideias e fazer parte dessa jornada!

Próximos Passos

Experimentação: Teste os módulos, analise os resultados e descubra como o TimeCraft pode se encaixar nos seus fluxos de trabalho.
Feedback & Contribuições: A comunidade é fundamental para transformar o projeto em algo ainda maior. Deixe seu feedback e compartilhe suas experiências.
Novas Integrações: Explore a integração com outras ferramentas, crie dashboards e desenvolva novas funcionalidades para ampliar o alcance desta ferramenta.

Estou animado para ver como cada um de vocês aproveitará esse projeto em suas soluções diárias!

Espero que essas ideias inspirem você a explorar novas maneiras de aproveitar o TimeCraft. E se você tiver outras perspectivas ou ideias para expandir essa ferramenta, compartilhe nos comentários – a troca de experiências é o que realmente impulsiona a inovação no mundo do desenvolvimento.

Bons códigos e até a próxima!

Logz (Logger Global em Golang) [pt-BR]

Rafa Mori — Sun, 02 Mar 2025 08:24:44 +0000

Introdução ao Logz: Um Logger Seguro e Flexível para Desenvolvedores Go e Uso Geral! 🚀

Abertura

Você está cansado de lidar com sistemas de log complicados e inseguros em suas aplicações Go? Imagine ter um logger que, além de repleto de recursos poderosos e segurança robusta, oferece uma experiência de uso incrivelmente suave para o desenvolvedor. Conheça o Logz—a solução open source que transforma totalmente seu fluxo de logging, combinando flexibilidade, segurança e integração com notificações. Seja durante o desenvolvimento local ou em ambientes de produção, o Logz está aqui para tornar seu processo de logging simples e eficaz.

Conteúdo Principal

Por que Logz?

Toda aplicação de qualidade precisa possuir um sistema de log confiável, mas na prática, o logging frequentemente é relegado a um segundo plano. Com o Logz, transformamos essa experiência ao dar ênfase a dois pilares essenciais: experiência do desenvolvedor e segurança. Veja o que diferencia o Logz:

Logging Orientado a Metadados:

Anexe facilmente informações contextuais—como requestId, user, ou outros campos relevantes—a cada entrada de log. Esses dados não são apenas informações extras: eles fornecem inteligência acionável, agilizando a depuração e o monitoramento.
Práticas de Build Seguras:

Logz utiliza a flag -trimpath do Go para remover caminhos absolutos sensíveis dos binários, além de recomendar a compressão dos executáveis com UPX para garantir que sejam leves e seguros. Aqui, a segurança não é opcional—ela é parte fundamental do design.
Opções de Saída Flexíveis:

Seja para exibir logs no console durante o desenvolvimento ou para gravá-los em arquivos em produção, o Logz oferece total controle. Suas flags de linha de comando permitem mudar facilmente a saída ou o formato, sem impor um único fluxo rígido.

Principais Funcionalidades

O Logz vem carregado de recursos para atender todas as suas necessidades de logging:

Suporte a Múltiplos Formatos de Log:

Escolha entre logs em texto, que facilitam a leitura humana, ou JSON, ideal para integração com sistemas de monitoramento.
Saída Alinhada e Amigável:

Desfrute de logs formatados de forma bonita, onde timestamps, níveis e metadados permanecem alinhados e organizados. Em logs de texto, os metadados são impressos em uma segunda linha (com indentação), garantindo clareza sem poluir a mensagem principal.
Controle Completo via CLI:

Com flags como --msg, --output, --metadata e --format, você tem controle total sobre cada entrada de log, podendo customizar a saída conforme necessário.
Integrações de Notificação:

Logz vai além do simples registro de mensagens, suportando notificações via webhooks HTTP, ZeroMQ e DBus. Assim, você pode configurar alertas em tempo real para eventos críticos, integrando com seus sistemas de monitoramento de forma transparente.
Instalador Inteligente no Primeiro Uso:

Para tornar a experiência ainda mais fluida, Logz inclui um instalador inteligente que, na primeira execução, verifica se o binário está instalado corretamente. Se não estiver, ele pode copiar o binário para o diretório apropriado (por exemplo, $HOME/.local/bin para usuários não-root ou /usr/local/bin para root) e atualizar o PATH automaticamente, garantindo que sua ferramenta esteja pronta para uso imediato.

Exemplos de Código Avançados

Exemplo 1: Logging Básico com Metadados

Execute o seguinte comando para registrar uma mensagem de debug com metadados contextuais:

logz debug \
  --msg "Depurando a nova funcionalidade com facilidade!" \
  --output "stdout" \
  --metadata requestId=12345,user=admin

Saída Esperada:

[2025-03-02T03:35:13Z] 🐛 DEBUG - Depurando a nova funcionalidade com facilidade!
                     {"requestId":"12345","user":"admin"}

Explicação:

Cada log exibe um timestamp, o nível (com um emoji para facilitar a identificação visual) e a mensagem principal. Os metadados são exibidos logo abaixo, com uma indentação que mantém a saída limpa e organizada.

Exemplo 2: Logging em Arquivo no Formato JSON

Para ambientes de produção, é comum utilizar JSON para facilitar a integração com sistemas de monitoramento. Por exemplo:

logz info \
  --msg "Serviço iniciado com sucesso." \
  --output "/var/log/meuapp/servico.log" \
  --format json \
  --metadata service=auth,version=v1.0.2

Saída Esperada (JSON):

{
  "timestamp": "2025-03-02T03:40:00Z",
  "level": "INFO",
  "message": "Serviço iniciado com sucesso.",
  "metadata": {
    "service": "auth",
    "version": "v1.0.2"
  }
}

Explicação:

As entradas de log são formatadas em JSON, permitindo que sejam facilmente processadas por agregadores de logs e sistemas de monitoramento.

Exemplo 3: Integração do Logz em um Microserviço Web

Veja como integrar Logz em um servidor HTTP no Go:

package main

import (
    "fmt"
    "net/http"
    "github.com/faelmori/logz/logger" // Ajuste o caminho conforme necessário
)

func main() {
    // Inicializa o logger com um prefixo customizado.
    log := logger.NewLogger("WebAPI: ")

    // Define um handler HTTP que loga os detalhes de cada requisição.
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Info("Requisição recebida", map[string]interface{}{
            "método": r.Method,
            "caminho": r.URL.Path,
        })
        fmt.Fprintf(w, "Olá, mundo!")
    })

    // Inicia o servidor HTTP, logando seu início.
    log.Info("Iniciando servidor na porta 8080", nil)
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatal("Falha ao iniciar servidor", map[string]interface{}{"erro": err})
    }
}

Explicação:

Cada requisição é logada com informações úteis que facilitam a análise do tráfego e a depuração de problemas. Se ocorrer um erro crítico, o log dispara um alerta via o método Fatal, que encerra o servidor.

Exemplo 4: Integração de Notificadores para Alertas em Tempo Real

Veja como você pode configurar notificadores para enviar alertas quando ocorrerem erros críticos:

package main

import (
    "time"
    "github.com/faelmori/logz/logger"
)

func main() {
    // Inicializa o logger e define metadados globais.
    log := logger.NewLogger("AlertService: ")
    log.SetMetadata("service", "payment")
    log.SetMetadata("env", "production")

    // Simula um erro que dispara um alarme.
    log.Error("Falha na transação de pagamento", map[string]interface{}{
        "transactionId": "txn_987654321",
        "timestamp":     time.Now().Format(time.RFC3339),
    })
}

Explicação:

Com os notificadores configurados no Logz, esta mensagem de erro pode, por exemplo, disparar um alerta via um webhook HTTP ou enviar uma notificação por DBus, garantindo uma resposta rápida a problemas críticos.

Exemplo 5: Instalador Inteligente no Primeiro Uso

Para aprimorar a experiência do usuário, Logz possui um instalador inteligente. No primeiro uso, o binário verifica se está corretamente instalado; se não estiver, ele se copia para o diretório apropriado e atualiza o PATH:

package main

import (
    "fmt"
    "io"
    "os"
    "os/exec"
    "path/filepath"
    "strings"
)

func isInPath() bool {
    pathEnv := os.Getenv("PATH")
    exePath, err := os.Executable()
    if err != nil {
        return false
    }
    exeDir := filepath.Dir(exePath)
    return strings.Contains(pathEnv, exeDir)
}

func updatePath(targetDir string) error {
    shell := filepath.Base(os.Getenv("SHELL"))
    var shellConfig string

    switch shell {
    case "bash":
        shellConfig = filepath.Join(os.Getenv("HOME"), ".bashrc")
    case "zsh":
        shellConfig = filepath.Join(os.Getenv("HOME"), ".zshrc")
    default:
        shellConfig = filepath.Join(os.Getenv("HOME"), ".profile")
    }

    fmt.Printf("Adicione a seguinte linha ao seu %s para incluir %s no PATH:\n", shellConfig, targetDir)
    fmt.Printf("export PATH=%s:$PATH\n", targetDir)
    return nil
}

func firstRunInstaller() {
    configFile := filepath.Join(os.Getenv("HOME"), ".logzconfig")
    if _, err := os.Stat(configFile); os.IsNotExist(err) {
        fmt.Println("Parece que é a primeira vez que você executa o Logz.")
        fmt.Print("Deseja instalar o Logz no seu sistema para facilitar o uso? (Y/n): ")
        var resp string
        fmt.Scanln(&resp)
        if strings.ToLower(resp) == "y" || resp == "" {
            exePath, err := os.Executable()
            if err != nil {
                fmt.Printf("Erro ao obter o caminho do executável: %v\n", err)
                return
            }
            targetDir := "/usr/local/bin"
            if os.Geteuid() != 0 {
                targetDir = filepath.Join(os.Getenv("HOME"), ".local", "bin")
            }
            target := filepath.Join(targetDir, "logz")
            cmd := exec.Command("cp", exePath, target)
            if err := cmd.Run(); err != nil {
                fmt.Printf("Erro durante a instalação: %v\n", err)
                return
            }
            fmt.Printf("Logz instalado em: %s\n", target)
            if err := updatePath(targetDir); err != nil {
                fmt.Printf("Falha ao atualizar o PATH: %v\n", err)
            }
            os.WriteFile(configFile, []byte("installed=true\n"), 0644)
        } else {
            os.WriteFile(configFile, []byte("skip_install=true\n"), 0644)
            fmt.Println("Instalação ignorada. Você pode instalá-lo manualmente depois.")
        }
    }
}

func main() {
    firstRunInstaller()
    fmt.Println("Logz está pronto para uso!")
}

Explicação:

Neste trecho, o programa verifica se um arquivo de configuração existe para determinar se é a primeira execução. Se for, ele questiona o usuário para instalar automaticamente o binário no diretório adequado e guia a atualização do PATH, proporcionando uma experiência “mágica” e sem complicações.

Destaques do Projeto

Open Source no GitHub:

Explore o código, contribua com melhorias ou simplesmente dê uma estrela se o Logz fizer sentido para você. Confira no GitHub.
Documentação Detalhada:

Toda a documentação está disponível em pkg.go.dev, proporcionando referências claras e guias de integração para facilitar sua adoção.

Conclusão e Chamada para Ação

O Logz não é apenas um logger—é uma ferramenta completa de observabilidade projetada para aplicações modernas em Go. Ao combinar práticas de build seguras, opções de saída flexíveis, manipulação rica de metadados e integrações inteligentes de notificações, o Logz capacita os desenvolvedores a monitorar e depurar suas aplicações com mais eficiência.

Experimente o Logz no seu próximo projeto Go e descubra como ele pode simplificar o seu fluxo de logging. Se o Logz facilitar sua vida, considere dar uma estrela no repositório do GitHub e compartilhar seu feedback. Juntos, podemos construir um ecossistema de logging mais inteligente, rápido e seguro—um log por vez!

Logz (Global Logger in Golang)

Rafa Mori — Sun, 02 Mar 2025 08:07:01 +0000

Introducing Logz: A Secure and Flexible Logger for Go Developers and General Use! 🚀

Opening Hook

Are you tired of wrestling with clunky, insecure logging systems in your Go applications? Imagine having a logger that not only packs powerful features and robust security into a single package but also delivers an incredibly smooth developer experience. Meet Logz—the open-source logging solution that transforms your logging workflow with flexibility, security, and integrated notification capabilities. Whether you’re developing locally or deploying in production, Logz is here to make your logging process seamless.

Main Content

Why Logz?

Every good application needs reliable logging. Yet too often, logging is treated as an afterthought. With Logz, we’ve turned logging into a first-class experience by focusing on two essential pillars: developer experience and security. Here’s how Logz stands out:

Metadata-Driven Logging:

Easily attach context—like requestId, user, or other relevant fields—to every log entry. This isn’t just extra data; it’s actionable intelligence that speeds up debugging and monitoring.
Secure Build Practices:

Logz leverages Go’s -trimpath flag to strip sensitive build paths from binaries, and we recommend compressing your executables with UPX to ensure they’re lightweight and secure. With these practices built in, secure logging isn’t an afterthought—it’s part of the design.
Flexible Output Options:

Whether you prefer logging to the console during development or to files in production, Logz gives you full control. Its CLI flags let you easily switch outputs, adjust formats, and don’t force you into one rigid workflow.

Key Features

Logz is built to cover all your logging needs while extending its functionality further:

Multiple Log Formats:

Choose between human-friendly text logs and machine-parsable JSON to fit your workflow.
Neatly Aligned Output:

Enjoy output where timestamps, log levels, and metadata are neatly aligned. For text logs, metadata is printed on a new indented line, enhancing readability without cluttering your primary log message.
Comprehensive CLI Control:

With flags such as --msg, --output, --metadata, and --format, you have fine-grained control over every aspect of your log entries.
Notification Integrations:

Logz can do more than just print logs. Its built-in notifier system supports HTTP webhooks, ZeroMQ, and DBus. This means you can set up real-time alerts whenever critical events occur, directly integrating with your existing monitoring systems.
Advanced First-Run Installer:

For a truly seamless experience, Logz features an intelligent first-run installer. Upon initial execution, Logz checks if it’s properly installed—and if not, it can automatically copy itself to the appropriate directory (e.g., $HOME/.local/bin for non-root users or /usr/local/bin for root users), and update the PATH so the tool is immediately accessible.

Extended Code Examples

Example 1: Basic Debug Logging with Metadata

Log a debug message with contextual metadata using:

logz debug \
  --msg "Debugging the latest feature with ease!" \
  --output "stdout" \
  --metadata requestId=12345,user=admin

Expected Output:

[2025-03-02T03:35:13Z] 🐛 DEBUG - Debugging the latest feature with ease!
                     {"requestId":"12345","user":"admin"}

Each log entry is timestamped and clearly displays the log level along with your message. The metadata, shown on an indented new line, ensures additional context is visible without cluttering the primary message.

Example 2: Logging to File in JSON Format

For production, you can output logs in JSON format:

logz info \
  --msg "Service started successfully." \
  --output "/var/log/myapp/service.log" \
  --format json \
  --metadata service=auth,version=v1.0.2

Expected Output (JSON):

{
  "timestamp": "2025-03-02T03:40:00Z",
  "level": "INFO",
  "message": "Service started successfully.",
  "metadata": {
    "service": "auth",
    "version": "v1.0.2"
  }
}

This format is ideal for integration with log aggregators and monitoring systems.

Example 3: Integrating Logz in a Microservice Web Application

Below is a snippet showing how to integrate Logz in an HTTP server:

package main

import (
    "fmt"
    "net/http"
    "github.com/faelmori/logz/logger" // Adjust the import path as needed
)

func main() {
    // Initialize the logger with a custom prefix.
    log := logger.NewLogger("WebAPI: ")

    // Define an HTTP handler to log request details.
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Info("Received request", map[string]interface{}{
            "method": r.Method,
            "path":   r.URL.Path,
        })
        fmt.Fprintf(w, "Hello, world!")
    })

    // Start the HTTP server.
    log.Info("Starting server on port 8080", nil)
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatal("Server failed to start", map[string]interface{}{"error": err})
    }
}

This example shows how every request and error is logged with useful metadata, making troubleshooting much easier.

Example 4: Notifier Integration for Real-Time Alerts

Logz’s notifier system allows you to send alerts via webhooks, ZeroMQ, or DBus. Here’s a brief example of how you might set up a notifier for critical errors:

package main

import (
    "github.com/faelmori/logz/logger"
    "time"
)

func main() {
    // Initialize the logger and set global metadata.
    log := logger.NewLogger("AlertService: ")
    log.SetMetadata("service", "payment")
    log.SetMetadata("env", "production")

    // Simulate an error to trigger a notifier.
    log.Error("Payment transaction failed", map[string]interface{}{
        "transactionId": "txn_987654321",
        "timestamp":     time.Now().Format(time.RFC3339),
    })
}

With the notifier setup in your configuration, this log entry might trigger an HTTP alert, a ZeroMQ message, or a DBus notification—whatever best suits your environment.

Example 5: Advanced First-Run Installer Logic

To address environment configuration automatically, Logz includes a first-run installer that checks if the binary is properly installed and, if not, copies itself to an appropriate directory and updates the PATH:

package main

import (
    "fmt"
    "io"
    "os"
    "os/exec"
    "path/filepath"
    "strings"
)

// isInPath checks if the current executable's directory is present in the PATH.
func isInPath() bool {
    pathEnv := os.Getenv("PATH")
    exePath, err := os.Executable()
    if err != nil {
        return false
    }
    exeDir := filepath.Dir(exePath)
    return strings.Contains(pathEnv, exeDir)
}

// firstRunInstaller checks if Logz is installed in the expected location and updates the PATH if necessary.
func firstRunInstaller() {
    configFile := filepath.Join(os.Getenv("HOME"), ".logzconfig")
    if _, err := os.Stat(configFile); os.IsNotExist(err) {
        fmt.Println("It looks like this is your first time using Logz.")
        fmt.Print("Would you like to install Logz for easier access? (Y/n): ")
        var response string
        fmt.Scanln(&response)
        if strings.ToLower(response) == "y" || response == "" {
            exePath, err := os.Executable()
            if err != nil {
                fmt.Printf("Error obtaining executable path: %v\n", err)
                return
            }
            targetDir := "/usr/local/bin"
            if os.Geteuid() != 0 {
                targetDir = filepath.Join(os.Getenv("HOME"), ".local", "bin")
            }
            target := filepath.Join(targetDir, "logz")
            cmd := exec.Command("cp", exePath, target)
            if err := cmd.Run(); err != nil {
                fmt.Printf("Installation error: %v\n", err)
                return
            }
            fmt.Printf("Logz installed to %s.\n", target)
            // Update PATH automatically by determining the user's shell config.
            shellConfig := ""
            switch filepath.Base(os.Getenv("SHELL")) {
            case "bash":
                shellConfig = filepath.Join(os.Getenv("HOME"), ".bashrc")
            case "zsh":
                shellConfig = filepath.Join(os.Getenv("HOME"), ".zshrc")
            default:
                shellConfig = filepath.Join(os.Getenv("HOME"), ".profile")
            }
            fmt.Printf("Adding %s to PATH in %s...\n", targetDir, shellConfig)
            f, err := os.OpenFile(shellConfig, os.O_APPEND|os.O_WRONLY, 0644)
            if err == nil {
                _, err := f.WriteString(fmt.Sprintf("\nexport PATH=%s:$PATH\n", targetDir))
                if err == nil {
                    fmt.Printf("PATH updated in %s. Run 'source %s' to apply changes.\n", shellConfig, shellConfig)
                }
                f.Close()
            } else {
                fmt.Printf("Failed to update %s. Please add %s to your PATH manually.\n", shellConfig, targetDir)
            }
            // Write to config file to avoid asking again.
            os.WriteFile(configFile, []byte("installed=true\n"), 0644)
        } else {
            os.WriteFile(configFile, []byte("skip_install=true\n"), 0644)
            fmt.Println("Installation skipped. You can install it later manually.")
        }
    }
}

func main() {
    // Try to run the first-run installer
    firstRunInstaller()

    // Continue with the normal program flow
    fmt.Println("Logz is ready to use.")
}

This code checks whether it's the first time Logz is being run, asks the user if they’d like it installed for easier access, and then automatically copies the executable and updates the PATH by modifying the appropriate shell configuration file. This automation greatly improves usability for users who may not be comfortable with manual PATH configuration.

Project Highlights

Open Source on GitHub:

Dive into the source, contribute your improvements, or star the repository if Logz resonates with you. See it on GitHub.
Detailed Documentation:

Comprehensive API references and integration guides are fully available on pkg.go.dev, making Logz easy to integrate into your projects.

Conclusion and Call-to-Action

Logz is not just a logger—it’s a complete observability tool for modern Go applications. It combines secure build practices, flexible output, rich metadata handling, and even smart notification integrations. Its advanced first-run installer ensures that Logz is set up perfectly on your system without the usual hassles.

If Logz simplifies your logging, consider giving it a try in your next Go project and sharing your thoughts on GitHub. Your feedback and support help us build a smarter, faster, and more secure logging ecosystem—one log entry at a time!

Changing the Login Shell with Security and Interactivity

Rafa Mori — Wed, 08 Jan 2025 16:34:52 +0000

Changing a user's login shell can be a simple task, but it involves several considerations to ensure security and convenience. This article presents a Bash script that exemplifies how to perform this change interactively and securely, using the dialog tool for user interaction and detailed validations to prevent errors or unsafe configurations.

Overview of the Script

The script changes the login shell in multiple steps, ensuring each action is validated before being applied. Among the main features of the script are:

Permission verification: The script requires the user to be in the sudo group, ensuring that only users with administrative privileges can make changes.
Interactivity with dialog: The dialog tool is used to display interactive menus, making it easy for the user to choose the new shell.
Validation of available and safe shells: The script checks if the chosen shell is listed in /etc/shells and is considered safe.
Shell change: Multiple methods are implemented to perform the shell change, with checks at each step.
Confirmation and feedback: The user is informed about the success or failure of the operation and instructed to restart the session if necessary.

Script Components and Functionality

1. Dependency Check

Before starting, the script checks if the user belongs to the sudo group and if the dialog command is installed:

if ! groups | grep -q '\bsudo\b'; then
    printf "The user is not in the sudo group.\n"
    exit 1
fi

if ! command -v dialog &> /dev/null; then
    printf "The dialog command is not available. Do you want to install it? (y/n) "
    read -r response
    if [[ ! "$response" =~ ^[Yy]$ ]]; then
      printf "Dialog installation canceled.\nPackage required to continue.\n"
      exit 0
    fi
    if ! sudo apt-get install -y dialog; then
        echo "Could not install dialog."
        exit 1
    fi
fi

This initial validation prevents the script from running without the necessary prerequisites, reducing the likelihood of failures.

2. Listing Available Shells

The script uses the /etc/shells file to retrieve the list of available shells and display them to the user in an interactive menu:

_AVAILABLE_SHELLS=$(grep -v '^#' "/etc/shells" | tr '\n' ' ')
_SHELL=$(dialog --menu "Choose the shell you want to use:" 15 50 10 $_AVAILABLE_SHELLS 3>&1 1>&2 2>&3)

This method ensures that only valid shells can be selected.

3. Safe Shell Validation

Before performing the change, the script checks if the chosen shell is safe by comparing it with a predefined list of allowed shells:

check_shell_safe() {
    local shell=$1
    local allowed_shells=(
      "/bin/sh" "/usr/bin/sh"
      "/bin/bash" "/usr/bin/bash"
      "/bin/zsh" "/usr/bin/zsh"
      # Other allowed shells
    )
    local forbidden_shells=("/bin/false" "/usr/sbin/nologin")
    [[ " ${allowed_shells[*]} " == *" $shell "* ]] && [[ -x $shell ]] && [[ $shell == /* ]] && [[ ! " ${forbidden_shells[*]} " == *" $shell "* ]]
}

This validation prevents unsafe or non-functional shells from being set as default.

4. Changing the Shell

The script implements three methods to change the user's shell:

Using the chsh command:

   chsh -s "$SHELL"

Using the usermod command:

   sudo usermod --shell "$SHELL" "$(id -un)"

Directly editing the /etc/passwd file:

   sudo sed -i "s|$_OLD_LINE|$_NEW_LINE|" "/etc/passwd"

These methods are applied in sequence, ensuring redundancy if one of them fails.

5. Verification and Feedback

After changing the shell, the script verifies whether the change was applied successfully and informs the user:

if verify_shell_change "$SHELL"; then
    dialog --msgbox "Shell successfully changed to $SHELL." 10 50
else
    dialog --msgbox "Could not change the shell." 10 50
    exit 1
fi

Importance of Validations

The validations implemented in the script ensure that only valid and safe shells are configured. This prevents issues such as:

Setting a nonexistent or invalid shell, making it impossible for the user to log in.
Using unsafe or disabled shells by default (e.g., /bin/false or /usr/sbin/nologin).

Conclusion

This script demonstrates how to automate and simplify the process of changing login shells with security and interactivity. It can be adapted to meet the specific needs of an environment, but best practices for validation and user feedback should be maintained to ensure its reliability and usability.

If you have questions or want to customize the script for your system, feel free to adjust the lists of allowed and forbidden shells or add new validation methods!

For more details, check out the script on GitHub: View the Gist. Feel free to follow me on GitHub, leave a comment, or contribute to the discussion!

Go Serialization Essentials: Struct Tags, Error Handling, and Real-World Use Cases

Rafa Mori — Mon, 06 Jan 2025 03:20:56 +0000

Introduction: Understanding Serialization and Deserialization in Go
Basic Concepts: Working with encoding/json and gopkg.in/yaml.v2
Practical Examples: Serialization and Deserialization in Go
- 3.1 Basic Serialization and Deserialization
- 3.2 Handling Complex and Nested Structures
- 3.3 Customization with Struct Tags
- 3.4 Error Handling
- 3.5 Generating Dynamic Code
Full Scenario: Real-World Use Case
Best Practices: Writing Efficient and Maintainable Serialization Code
Conclusion

1. Introduction: Understanding Serialization and Deserialization in Go

Serialization and deserialization are key concepts in software development that help in the storage, transmission, and manipulation of data. In Go, serialization refers to the process of converting a data structure into a format that can be easily stored or transmitted (e.g., JSON, YAML, or binary). Deserialization is the reverse process, where serialized data is converted back into a Go data structure.

In Go, serialization and deserialization are made easy through standard libraries and third-party packages. This article will explore the basic concepts of these processes and show you how to effectively work with data in Go using popular packages like encoding/json and gopkg.in/yaml.v2.

2. Basic Concepts: Working with `encoding/json` and `gopkg.in/yaml.v2`

Go provides built-in support for handling JSON through the encoding/json package, which offers functions like Marshal (to serialize) and Unmarshal (to deserialize). Similarly, gopkg.in/yaml.v2 is a popular third-party package used for working with YAML data, providing functions like yaml.Marshal and yaml.Unmarshal.

encoding/json: This package allows you to easily convert Go objects into JSON format and vice versa. It supports encoding/decoding both simple and complex data structures.
gopkg.in/yaml.v2: This package is widely used for working with YAML in Go. YAML is a human-readable data serialization format, often used in configuration files, and Go’s YAML package allows you to encode and decode Go structs with ease.

These packages allow you to work with different data formats in Go seamlessly, enabling easier data exchange, storage, and processing.

3. Practical Examples: Serialization and Deserialization in Go

Now, let's explore practical examples of how serialization and deserialization work in Go.

3.1 Basic Serialization and Deserialization

First, let's look at how to serialize and deserialize basic data structures in JSON and YAML.

Code:

package main

import (
    "fmt"
    "encoding/json"
    "gopkg.in/yaml.v2"
)

// Basic data structure.
type Person struct {
    Name string `json:"name" yaml:"name"`
    Age  int    `json:"age" yaml:"age"`
}

func main() {
    // Create an instance of Person
    person := Person{Name: "John", Age: 30}

    // Serialize to JSON
    jsonData, _ := json.Marshal(person)
    fmt.Println("JSON:", string(jsonData))

    // Serialize to YAML
    yamlData, _ := yaml.Marshal(person)
    fmt.Println("YAML:", string(yamlData))

    // Deserialize JSON
    var jsonPerson Person
    json.Unmarshal(jsonData, &jsonPerson)
    fmt.Println("Deserialized from JSON:", jsonPerson)

    // Deserialize YAML
    var yamlPerson Person
    yaml.Unmarshal(yamlData, &yamlPerson)
    fmt.Println("Deserialized from YAML:", yamlPerson)
}

Explanation:

This example demonstrates basic serialization and deserialization of a simple Person struct into both JSON and YAML formats. The json.Marshal and yaml.Marshal functions are used to serialize the data, while json.Unmarshal and yaml.Unmarshal are used for deserialization.

3.2 Handling Complex and Nested Structures

Go allows us to serialize and deserialize more complex data structures, including nested structs, arrays, and slices.

Code:

type Address struct {
    Street string `json:"street" yaml:"street"`
    City   string `json:"city" yaml:"city"`
}

type PersonWithAddress struct {
    Name    string  `json:"name" yaml:"name"`
    Age     int     `json:"age" yaml:"age"`
    Address Address `json:"address" yaml:"address"`
}

func main() {
    address := Address{Street: "123 Main St", City: "Gotham"}
    person := PersonWithAddress{Name: "Bruce Wayne", Age: 35, Address: address}

    // Serialize to JSON
    jsonData, _ := json.Marshal(person)
    fmt.Println("JSON:", string(jsonData))

    // Serialize to YAML
    yamlData, _ := yaml.Marshal(person)
    fmt.Println("YAML:", string(yamlData))
}

Explanation:

Here, we serialize and deserialize a nested structure PersonWithAddress, which contains an embedded struct Address. Both JSON and YAML serialization are handled automatically by the respective packages.

3.3 Customization with Struct Tags

Go structs can include tags that specify how fields are serialized into different formats. These tags allow for customization, such as renaming fields or excluding them from serialization.

Code:

type CustomPerson struct {
    Name    string `json:"full_name" yaml:"full_name"`
    Age     int    `json:"-" yaml:"-"` // Exclude from serialization
    Email   string `json:"email,omitempty" yaml:"email,omitempty"` // Omit if empty
}

func main() {
    person := CustomPerson{Name: "Alice", Age: 25, Email: ""}

    // Serialize to JSON
    jsonData, _ := json.Marshal(person)
    fmt.Println("JSON:", string(jsonData))

    // Serialize to YAML
    yamlData, _ := yaml.Marshal(person)
    fmt.Println("YAML:", string(yamlData))
}

Explanation:

In this example, the CustomPerson struct uses tags to control how the fields are serialized. The Age field is excluded from both JSON and YAML serialization, and the Email field is omitted if it is empty (omitempty tag).

3.4 Error Handling

Proper error handling is crucial in serialization and deserialization. Let’s add error checks to ensure that any issues during encoding or decoding are handled gracefully.

Code:

func safeMarshal(v interface{}) (string, error) {
    data, err := json.Marshal(v)
    if err != nil {
        return "", fmt.Errorf("Error serializing data: %v", err)
    }
    return string(data), nil
}

func main() {
    // Example with error handling
    person := Person{Name: "John", Age: -5} // Invalid data (Age cannot be negative)

    jsonData, err := safeMarshal(person)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("JSON:", jsonData)
    }
}

Explanation:

In this example, the safeMarshal function wraps the json.Marshal call and provides error handling, ensuring that if there is an issue during serialization, it will be caught and logged.

3.5 Generating Dynamic Code

Go’s reflection capabilities allow us to generate functions that can handle serialization and deserialization dynamically based on the data types at runtime.

Code:

import "reflect"

func generateSerializationFunction(v interface{}) string {
    typ := reflect.TypeOf(v).Elem()
    return fmt.Sprintf("func Serialize%s(data %s) string { ... }", typ.Name(), typ.Name())
}

func main() {
    var person Person
    code := generateSerializationFunction(&person)
    fmt.Println("Generated Code:", code)
}

Explanation:

In this example, we use reflection to dynamically generate a function that could serialize any given struct type. This can be useful when dealing with various data structures in large applications.

Full Scenario: Real-World Use Case {#full-scenario}

Let’s demonstrate a real-world use case where these techniques are applied. Imagine a web API that accepts both JSON and YAML as input formats, stores data in a database, and generates dynamic SQL queries for data insertion.

Code:

// Example of serializing data for a web API
func apiRequestHandler(data []byte) {
    var user Person
    err := json.Unmarshal(data, &user)
    if err != nil {
        // Handle error
    }
    // Generate SQL query for database insertion
    sqlQuery := GenerateSQLInsert(&user)
    fmt.Println("Generated SQL:", sqlQuery)
}

Explanation:

In this real-world example, we deserialize incoming data (in JSON format) into Go structs, then use it to generate an SQL query for data insertion into a database. This demonstrates how serialization, deserialization, and dynamic code generation can be integrated in practical scenarios.

5. Best Practices: Writing Efficient and Maintainable Serialization Code

Error Handling: Always handle errors properly. Ensure that both serialization and deserialization processes account for malformed or unexpected data.
Use Struct Tags: Make good use of struct tags to control serialization behavior (e.g., field names, omissions, custom rules).
Avoid Overusing Reflection: Reflection is powerful but can lead to less readable and harder-to-maintain code. Use it only when necessary.
Optimize Performance: When dealing with large datasets, consider using streaming methods like json.NewEncoder and json.NewDecoder for better performance.
Test with Different Formats: Always test your serialization and deserialization functions with various input scenarios to ensure robustness.

6. Conclusion

In this article, we explored the fundamentals of serialization and deserialization in Go using JSON and YAML. We covered basic and complex structures, customization using struct tags, error handling, and dynamic code generation. Additionally, we provided a real-world scenario to demonstrate the practical application of these techniques.

As you continue working with Go, consider exploring more advanced topics like performance optimizations, custom encoding/decoding methods, and integrations with third-party libraries for even more powerful data manipulation.

Creating Safe Custom Types with Validation in Go

Rafa Mori — Sun, 05 Jan 2025 12:52:04 +0000

Introduction

In Go programming, creating custom types with validation is paramount for ensuring data integrity and security. This article explores a code structure that exemplifies the creation of a custom type, incorporating robust validation and adhering to best practices for safety and compliance.

Code Structure

Let's break down the essential components:

Necessary Imports:

import (
        "fmt"
        "strings"
)

Custom Type Definition:

type Example string

We define a custom type Example as a string, providing a clear and concise representation of the data.

Constants and Allowed Options:

const (
        ArgumentA = "value_a"
        ArgumentB = "value_b"
)

var AllowedOptions = []string{string(ArgumentA), string(ArgumentB)}

We define constants for allowed values and store them in a slice for easy reference and management.

Methods for the Example Type:

String(): Returns the string representation of the Example value.

func (f Example) String() string {
        return string(f)
}

Type(): Returns the name of the type.

func (f *Example) Type() string {
        return "Example"
}

Set(): Validates the input value and sets the Example value if valid.

func (f *Example) Set(value string) error {
        for _, exampleOption := range AllowedOptions {
                if exampleOption == value {
                        *f = Example(value)
                        return nil
                }
        }
        return fmt.Errorf("allowed values: %s", strings.Join(AllowedOptions, ", "))
}

Advantages of Using Custom Types with Validation

Enhanced Data Security: By rigorously validating input, we prevent invalid or malicious data from entering the system, bolstering overall security.
Improved Compliance: Adhering to validation rules helps ensure compliance with relevant standards like GDPR or HIPAA.
Increased Code Maintainability: Custom types promote modularity and make code easier to maintain and extend.
Enhanced Type Safety: Go's type system provides compile-time checks, minimizing runtime errors and improving code quality.
Improved Code Readability: Custom types make code more self-documenting, enhancing understanding and collaboration.

Conclusion

Employing custom types with validation in Go is a best practice for developing robust, secure, and maintainable applications. This approach is particularly valuable in scenarios demanding high data integrity, such as financial systems or healthcare applications.

Additional Considerations

Thorough Testing: Rigorous testing of custom types, especially the Set method, is crucial to ensure validation works as expected.
Meaningful Error Handling: Provide informative error messages to aid in debugging and troubleshooting.
Contextual Adaptation: Tailor validation logic to specific use cases, such as command-line arguments or configuration file parsing.

By embracing custom types with validation, you can significantly enhance the quality, security, and reliability of your Go applications.

Complete Code Example:

package main

// Package flags provides custom flag types
import (
    "fmt"
    "strings"
)

// Example is a custom type that implements the flag.Value interface.
type Example string

// Example values.
const (
    ArgumentA = "value_a"
    ArgumentB = "value_b"
)

// AllowedOptions is a list of allowed values for the Example type.
var AllowedOptions = []string{string(ArgumentA), string(ArgumentB)}

// String returns the string representation of the Example type.
func (f Example) String() string {
    // Return the string representation of the Example type.
    return string(f)
}

// Type returns the type name of the Example type.
func (f *Example) Type() string {
    // Return the type name.
    return "Example"
}

// Set validates and sets the value for the Example type.
// It returns an error if the value is not allowed.
func (f *Example) Set(value string) error {
    // Check if the value is allowed.
    for _, exampleOption := range AllowedOptions {
        // If the value is allowed, set it and return nil.
        if exampleOption == value {
            // Set the value.
            *f = Example(value)
            return nil
        }
    }

    // If the value is not allowed, return an error.
    return fmt.Errorf("allowed values: %s", strings.Join(AllowedOptions, ", "))
}

func main() {
        // Example usage:
        var myExample Example
        err := myExample.Set("value_a")
        if err != nil {
                fmt.Println(err)
        } else {
                fmt.Println("Set value:", myExample)
        }
}

Changing an established SSH connection without disconnecting

Rafa Mori — Tue, 31 Dec 2024 14:46:28 +0000

Understanding SSH Escape Characters

Introduction

SSH (Secure Shell) is a widely used protocol for securing remote terminal sessions. When working with SSH, you may sometimes need to use escape characters to perform specific functions within an SSH session. Understanding how to use these escape characters effectively can significantly improve your SSH experience and troubleshooting capabilities. In this article, we'll explore what escape characters are, how to use them, and provide some practical examples to illustrate their utility.

What is an Escape Character?

An escape character is a special character that allows users to execute certain functions within an SSH session. By default, this character is the tilde ~. To send a single tilde, you can either use ~~ or follow the tilde with any character other than the specified functions. The escape character must always be preceded by a newline to be interpreted correctly. You can change this character in configuration files using the EscapeChar directive or on the command line with the -e option.

Supported Escape Sequences

The following escape sequences are supported when the default tilde ~ is used:

Command Line Access with `~C`

One of the most powerful escape sequences is ~C, which opens a command line for adding port forwardings using the -L, -R, and -D options. Basic help is also available with the -h option. Here's how to use it:

Type Enter~C (i.e., a capital C).
Add your port forwarding command, such as:
```
-L localport:server:serverport
```
Replace localport, server, and serverport with your desired values, and then press Enter.

Practical Examples

Example 1: Adding a Port Forwarding

Imagine you need to access a web server running on a remote machine but want to forward it through a local port. You would use the ~C command as follows:

Enter~C
-L 8080:localhost:80
Enter

This will forward the remote web server (port 80) to your local machine's port 8080.

Example 2: Terminating an SSH Session

If you need to quickly terminate your SSH session, you can use the escape sequence:

Enter~.

This sequence immediately closes the SSH connection.

Practical Considerations

Timing: Choose the right moment to press Enter, as it will be immediately sent to the remote side and may trigger some action there. Do this when you are at a shell prompt with an empty command line.
International Keyboards: For internationalized keyboards where the tilde might be a dead key (e.g., pressing ~n to generate ñ), it might be necessary to press SPACE after the tilde to generate a single tilde, i.e., ENTER~SPACEC. On Spanish/Latin American keyboard layouts, since there are no combined characters using tilde and C, the space can be omitted.

Multiple Redirections

The SSH escape command line only accepts one command at a time. To enter multiple commands or redirections, you need to press the keyboard sequence again for each new command.

Enabling `~C` in SSH Client v9.2 and Later

For SSH client version 9.2 and later, the ~C command line must be manually enabled using either the -o EnableEscapeCommandline=yes option or by adding the EnableEscapeCommandline option in your ~/.ssh/config file.

The Fascination of Dynamic Port Forwarding

One of the most intriguing uses of SSH escape characters is the ability to insert port forwardings into already established SSH connections. This functionality, enabled by the ~C escape sequence, allows for dynamic adjustment of port forwardings without the need to restart the SSH session.

Why It's Fascinating

This ability is especially valuable in situations where new requirements arise during an active session. Imagine you're connected to a remote server and suddenly need to forward a new port. Instead of terminating the session and starting over, you can seamlessly add the forwarding using the escape sequence.

Here’s a detailed example:

Example: Dynamic Port Forwarding

Establish an SSH Session:
```
ssh user@remotehost
```
Initiate Port Forwarding within the Session:
- Ensure you are at a shell prompt with an empty command line.
- Type Enter~C to open the escape command line.
- Add the port forwarding command:
```
  -L 3306:localhost:3306
```

- Press Enter.

This command dynamically forwards the remote server's port 3306 (typically used by MySQL) to your local machine's port 3306, allowing you to interact with the remote database as if it were local.

Security Considerations

While dynamic port forwarding is a powerful feature, it comes with security risks:

Unauthorized Access: Be vigilant about who has access to use escape sequences, as they can potentially redirect sensitive ports.
Monitoring: Actively monitor SSH sessions to detect any unauthorized or unusual activity.
Configuration Management: Secure your ~/.ssh/config and related configuration files to prevent unauthorized changes.

By understanding and leveraging this feature with caution, you can significantly enhance the flexibility and functionality of your SSH sessions. Stay secure and make the most out of your SSH connections!

References

Kicksecure: Hardening Your Linux System’s Security (Debian Morph)

Rafa Mori — Sun, 29 Dec 2024 05:17:08 +0000

Enhancing Digital Security with Kicksecure: How to Install and Why You Should Use It

In today's digital age, data security is more important than ever. Kicksecure is a security-focused Linux distribution designed to protect your data and privacy. In this article, we will show you how to install Kicksecure and explain why it is an excellent choice for users who want to strengthen their system's security.

What is Kicksecure?

Kicksecure is a security-focused Linux distribution based on Debian. It is designed to be secure by default, incorporating a series of security enhancements that help protect the system from various cyber threats. One of Kicksecure’s key features is kernel hardening.

What is Kernel Hardening?

The kernel is the core of the operating system, responsible for managing system resources and enabling communication between hardware and software. Kernel hardening refers to applying various techniques to increase the security of the kernel, making it more resistant to attacks.

Some of the techniques used in kernel hardening include:

Access restrictions: Limiting the privileges of users and processes.
Memory protection: Preventing unauthorized access to system memory.
Secure code execution: Blocking the execution of unauthorized code.

These measures make the system less vulnerable to attacks that exploit kernel flaws.

Why Install Kicksecure?

There are many reasons to choose Kicksecure, but here are the top three in my opinion:

Security by Default: Kicksecure comes pre-configured with security enhancements, making it secure from the start.
Enhanced Privacy: It protects your data and communications, preventing information leaks.
Ease of Use: Despite being highly secure, Kicksecure is designed to be user-friendly, even for those with less experience.

Before Installing Kicksecure

To increase the chances of a successful installation, it is best to start with a minimal Debian installation. You can choose to install either:

A) Debian with a graphical user interface (GUI) (Xfce)
B) Debian with a command-line interface (CLI)

Once the base installation is complete, you can install the Kicksecure meta package as outlined below.

Tip: It's easiest to set the user account name as "user" during the installation of Debian Bookworm.

Considerations for the Distro-Morphing Process

When performing Distro-Morphing, the user should be aware of the following:

No user account creation: The process does not create user or admin accounts. You can continue using your existing user accounts.
No password changes: No passwords for any existing user accounts will be modified. This means passwords for Full Disk Encryption (pre-boot authentication), sudo, su, login, etc., will remain the same.
No root account locking: The password for the root account will not be locked. If desired, the user can manually disable the root account for better security.
Autologin: The usability-misc package will set up auto-login for the "user" account on LightDM, Kicksecure's default login manager at the time of writing. Auto-login can be disabled by following the documentation for disabling autologin.

Installing Kicksecure (Distro-Morphing Method)

Let’s start with the installation process. First, you'll need to become the root user.

To do this, run the following command in your terminal:

su

If running su alone doesn’t work (depending on how Debian was installed), try:

sudo su

Next, ensure the following basic tools are installed on your system before proceeding. Here is the full list:

adduser
console
console-data
console-common
kbd
keyboard-configuration
extrepo

Now that you have the basics covered, let's walk through the installation process step by step.

1. Update the Package Lists

To begin, update your package lists to ensure your system is aware of the latest available software:

apt update

2. Upgrade the System

Next, upgrade your system to make sure all your installed packages are up to date:

apt full-upgrade

3. Install Essential Packages

Install sudo and adduser packages, which are necessary for configuring user permissions:

apt install --no-install-recommends sudo adduser

4. Sudo Configuration (Optional)

If you'd like to allow the user to run sudo commands without entering a password, follow one of these methods:

adduser Method:

Add your user to the sudo group:

/usr/sbin/adduser user sudo

Reboot your system:

/sbin/reboot

file Method:

Securely create the file /etc/sudoers.d/user.conf using visudo:

echo "user ALL=(ALL:ALL) NOPASSWD:ALL" | EDITOR=tee visudo -f /etc/sudoers.d/nopassword >/dev/null

5. Create the Console Group

Create a system group named console:

/usr/sbin/addgroup --system console

6. Add User to Console Group

Add your user to the console group (replace "user" with your actual username):

/usr/sbin/adduser user console

7. Install Console-Related Packages

Install the necessary console-related packages. This step may also remove the unsupported plymouth, which is a positive outcome for security purposes:

sudo apt install console-data console-common kbd keyboard-configuration

8. Install the `extrepo` Package

Install the extrepo package to enable external repositories:

sudo apt install extrepo

9. Enable the Kicksecure APT Repository

Enable the stable Kicksecure APT repository using the following command:

sudo extrepo enable kicksecure

10. Install Kicksecure Packages

Finally, install the Kicksecure package for your desktop environment. For this guide, we will use the Xfce environment, which is known for its lightweight nature and low resource consumption. To install the Kicksecure Xfce Host package, use the following command:

sudo apt install --no-install-recommends kicksecure-xfce-host

11. Update and Upgrade Again

It’s always a good practice to run an update and full-upgrade after adding new repositories and packages:

sudo apt update && sudo apt full-upgrade

Why Kicksecure is an Excellent Choice

Kicksecure is a fantastic option for anyone looking to bolster their system's security with hardening techniques and enjoy a secure workspace. Here are some key reasons why it stands out:

Hardening Made Easy: Kicksecure offers a pre-configured, secure-by-default environment that is specifically designed for those who value security. It’s one of the most robust distributions for those looking to minimize vulnerabilities and ensure their system is hardened against cyber threats.
Xfce4: Lightweight and Efficient: One of the most notable aspects of Kicksecure is that it uses Xfce4, a highly lightweight desktop environment. Xfce4 is known for its low resource usage, making it a great choice for users who want a fast and responsive system without sacrificing performance. It’s an ideal environment for both experienced users and newcomers alike, ensuring smooth operation even on older hardware.
Security Without Compromise: Kicksecure focuses on providing a secure operating environment without sacrificing usability. Its hardened kernel, combined with a simple yet powerful desktop experience, makes it an excellent choice for those who need enhanced security but also want a comfortable

Forem: Rafa Mori

🚀 LookAtni File Markers — Invisible Markers to Structure Your Files Like Magic

🧠 How it works

📸 See it in action

🧰 Use cases

🔧 Built-in CLI (coming soon)

📦 Install now

❤️ Open Source

🚀 LookAtni File Markers — Marcadores invisíveis para estruturar seus arquivos como mágica

🧠 Como funciona?

📸 Veja em ação

🧰 Casos de uso

🔧 CLI embutido (em breve)

📦 Instale agora

❤️ Open Source

🚀 Ollama Dev Stack: WebUI + Benchmark + Docker + Fallback (Open Source)

Um ambiente local completo para rodar LLMs como deepseek-coder e mistral com Docker, Open-WebUI, benchmarks automáticos, fallback inteligente e uma DX otimizada via Makefile ou script Bash — tudo open source, tudo fácil de estender!

🧠 Por que criei isso?

🔧 O que tem no stack?

🧪 Exemplos de uso

🌍 Acesse o WebUI

📁 Repositório e Gist

📄 Licença

TimeCraft: Simplifying Time Series Analysis and Automation

Why TimeCraft?

Main Features

Usage Examples

Scheduling Executions

Notifications via Webhook

Exploring New Possibilities

Final Thoughts

Next Steps

TimeCraft: Simplificando Análise de Séries Temporais e Automação

Por Que TimeCraft?

Recursos Principais

Exemplos de Uso

Agendamento de Execuções

Notificações via Webhook

Explorando Novas Possibilidades

Considerações Finais

Próximos Passos

Logz (Logger Global em Golang) [pt-BR]

Introdução ao Logz: Um Logger Seguro e Flexível para Desenvolvedores Go e Uso Geral! 🚀

Abertura

Conteúdo Principal

Por que Logz?

Principais Funcionalidades

Exemplos de Código Avançados

Exemplo 1: Logging Básico com Metadados

Exemplo 2: Logging em Arquivo no Formato JSON

Exemplo 3: Integração do Logz em um Microserviço Web

Exemplo 4: Integração de Notificadores para Alertas em Tempo Real

Exemplo 5: Instalador Inteligente no Primeiro Uso

Destaques do Projeto

Conclusão e Chamada para Ação

Logz (Global Logger in Golang)

Introducing Logz: A Secure and Flexible Logger for Go Developers and General Use! 🚀

Opening Hook

Main Content

Why Logz?

Key Features

Extended Code Examples

Example 1: Basic Debug Logging with Metadata

Example 2: Logging to File in JSON Format

Example 3: Integrating Logz in a Microservice Web Application

Example 4: Notifier Integration for Real-Time Alerts

Example 5: Advanced First-Run Installer Logic

Project Highlights

Conclusion and Call-to-Action

Changing the Login Shell with Security and Interactivity

Overview of the Script

Script Components and Functionality

1. Dependency Check

2. Listing Available Shells

3. Safe Shell Validation

4. Changing the Shell

5. Verification and Feedback

Importance of Validations

Conclusion

Go Serialization Essentials: Struct Tags, Error Handling, and Real-World Use Cases

Um ambiente local completo para rodar LLMs como `deepseek-coder` e `mistral` com Docker, Open-WebUI, benchmarks automáticos, fallback inteligente e uma DX otimizada via Makefile ou script Bash — tudo open source, tudo fácil de estender!

2. Basic Concepts: Working with `encoding/json` and `gopkg.in/yaml.v2`

Command Line Access with `~C`

Enabling `~C` in SSH Client v9.2 and Later

8. Install the `extrepo` Package