Forem: Walter Emmanuel Salas Jimenez

🔭 Observability Practices: The 3 Pillars with a Node.js + OpenTelemetry Example

Walter Emmanuel Salas Jimenez — Mon, 01 Dec 2025 19:09:09 +0000

🚀 Demystifying Observability: A Practical Guide with Node.js, OpenTelemetry, Prometheus, and Grafana

🧐 Link to the practice repository: Wsalas651/observability-demo

In the modern era of distributed systems and microservices, relying solely on traditional monitoring is like trying to diagnose a complex illness with just a thermometer. Monitoring tells you when a problem exists (e.g., "CPU usage is high"), but Observability gives you the tools to understand why the problem is happening.

What is Observability?

Observability is a property of a system that allows an operator to infer its internal state by examining its external outputs. It's the ability to ask arbitrary questions about your system without having to release new code to answer them.

It is universally defined by its three pillars:

Metrics (The Numeric Story): These are aggregated numerical measurements collected over time. They tell you how much or how often something is happening. They are best for time-series analysis and spotting trends.
- Examples: Request count, latency percentiles, CPU usage, memory consumption.
Logs (The Discrete Events): These are immutable, timestamped text records of discrete events that occurred at a specific point in time. They are the "what happened when" data.
- Examples: User X logged in, a database query failed, a transaction was processed.
Traces (The Request's Journey): A trace represents the end-to-end path of a single request or transaction as it flows through a distributed system. They are crucial for debugging latency issues in microservice architectures.
- Examples: A user clicking a button initiates calls across Service A, Service B, and a Database, showing the time spent in each.

Why Observability Matters

In a monolithic application, debugging might be challenging, but the data is centralized. In a microservices environment, a single user click can trigger a chain of calls across dozens of services written in different languages.

Observability allows you to:

Reduce Mean Time To Resolution (MTTR): Spend less time guessing and more time fixing.
Handle Unknown-Unknowns: Debug issues you never anticipated.
Improve System Health: Use the data to refactor bottlenecks and optimize resource usage.

🛠️ Practical Example: Observability with Node.js and OpenTelemetry

We will demonstrate how to instrument a simple Node.js Express API using OpenTelemetry for both metrics and traces, and then visualize that data using Prometheus and Grafana.

The Observability Stack

Application: A simple Node.js Express API.
Instrumentation: OpenTelemetry (OTEL). This is a vendor-neutral standard for instrumenting code.
Metrics Store: Prometheus, which scrapes metrics from the app.
Visualization: Grafana, for building dashboards on the Prometheus data.
Orchestration: Docker Compose to run the full stack.

Step 1: Instrumenting the Node.js API

Our application needs to expose its internal state. We use OpenTelemetry to set up tracing and custom Prometheus metrics.

1. OpenTelemetry Tracing Setup (`app/src/tracer.js`)

OpenTelemetry handles the heavy lifting of exporting trace data. This file initializes the tracer, ensuring every request across services is connected.

// app/src/tracer.js
// tracer.js - sets up OpenTelemetry to send traces to Jaeger
const { NodeSDK } = require('@opentelemetry/sdk-node');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');
const { JaegerExporter } = require('@opentelemetry/exporter-jaeger');

function setupTracing(serviceName = 'observability-demo-app') {
  const exporter = new JaegerExporter({
    endpoint: 'http://jaeger:14268/api/traces'
    // For UDP agent: { host: 'jaeger', port: 6832 }
  });

  const sdk = new NodeSDK({
    traceExporter: exporter,
    instrumentations: [getNodeAutoInstrumentations()],
    serviceName
  });

  sdk.start()
    .then(() => {
      console.log('OpenTelemetry initialized');
    })
    .catch((err) => {
      console.error('Error starting OpenTelemetry SDK', err);
    });

  // Optionally handle graceful shutdown
  process.on('SIGTERM', () => {
    sdk.shutdown()
      .then(() => console.log('Tracing terminated'))
      .catch((e) => console.log('Error terminating tracing', e));
  });
}

module.exports = { setupTracing };

2. Custom Metrics (app/src/metrics.js)

While OTEL provides basic metrics, custom metrics are essential for business logic. We use the standard prom-client library (which OTEL often leverages) to define and track two core metrics:

// metrics.js - registers Prometheus metrics
const client = require('prom-client');

// Default metrics (CPU, memory etc.)
client.collectDefaultMetrics({
  timeout: 5000
});

// Create a Registry (could use default registry)
const register = client.register;

// HTTP request metrics
const httpRequestCounter = new client.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'route', 'status']
});

const httpRequestDuration = new client.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'route', 'status'],
  buckets: [0.005, 0.01, 0.05, 0.1, 0.3, 1, 3, 5]
});

function metricsMiddleware(req, res, next) {
  const end = httpRequestDuration.startTimer();
  res.on('finish', () => {
    const route = req.route ? req.route.path : req.path;
    httpRequestCounter.inc({ method: req.method, route, status: res.statusCode });
    end({ method: req.method, route, status: res.statusCode });
  });
  next();
}

module.exports = { register, metricsMiddleware };

Step 2: Orchestration with Docker Compose

Your docker-compose.yml ties the entire stack together, defining the application, Prometheus, and Grafana services.

version: '3.8'
services:
  app:
    build: ./app
    image: observability-demo-app:latest
    container_name: observability-demo-app
    ports:
      - "3000:3000"
    environment:
      - PORT=3000
    depends_on:
      - prometheus
      - jaeger

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    depends_on:
      - prometheus
    ports:
      - "3001:3000"
    volumes:
      - ./grafana/provisioning:/etc/grafana/provisioning:ro
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

  jaeger:
    image: jaegertracing/all-in-one:1.39
    container_name: jaeger
    ports:
      - "16686:16686"   # Jaeger UI
      - "14268:14268"   # Jaeger collector (HTTP)

Step 3: Seeing the README.md of the repository.

Conclusion

Observability is a critical capability, not just a toolset. By adopting a standard like OpenTelemetry and leveraging powerful open-source tools like Prometheus and Grafana, you gain the ability to move beyond basic monitoring and truly understand the internal behavior of your distributed applications.

Stop guessing, start observing! Happy coding! 🚀

🚀 Build a Remote MCP Server That Connects to Any MCP Client (Claude, VSCode & More)

Walter Emmanuel Salas Jimenez — Mon, 01 Dec 2025 16:18:51 +0000

The Model Context Protocol (MCP) is quickly becoming the new universal standard for connecting AI assistants with real-world tools. Imagine giving Claude, VSCode, or any MCP-compatible client the power to interact with your APIs, databases, scripts, or cloud resources—securely and consistently.

In this guide, you’ll learn:

✨ What an MCP Server is

⚙️ How to build one

🔌 How MCP Clients connect

🧰 Deployment options (Cloudflare, Cloud Run, custom hosting)

💻 Example code + a public repository template

🧠 What Is an MCP Server?

An MCP Server is a backend service that exposes tools, resources, prompts, or custom logic to AI clients through a standardized protocol.

Think of it as:

🛠️ Your own plugin system for AI models.

If you can code it, an LLM can use it.

With an MCP Server, you can expose:

📡 API requests
🗂️ Database queries
💾 File operations
🔐 Secure internal tools
🧮 Business logic
🛠️ Any custom code/functionality

And any MCP Client can use it immediately:

Claude Desktop
Claude on Web (with model contexts)
VSCode MCP Extension
Cursor (partial)
Custom terminals or agents

🔌 How MCP Servers Connect to Clients

MCP uses a clean JSON-based message protocol on top of common transports:

🔗 WebSockets
🧵 STDIO
🌐 HTTP Streaming
☁️ Cloudflare Workers Channels
🚀 Google Cloud Run HTTP endpoints

Clients send messages like:

initialize
list_tools
call_tool
read_resource

And the server responds with structured results.

This design makes MCP servers portable, cloud-ready, and language-agnostic 💡.

🛠️ Minimal MCP Server Example (TypeScript)

Below is a simple starter server that exposes one tool called hello_world:

import { Server, Tool } from "@modelcontextprotocol/sdk/server";

const server = new Server({
  name: "example-mcp-server",
  version: "1.0.0",
});

server.tool(
  new Tool("hello_world", {
    description: "Returns a greeting message.",
    inputSchema: {
      type: "object",
      properties: {
        name: { type: "string" },
      },
      required: ["name"],
    },
    async handler({ name }) {
      return { message: `Hello, ${name}!` };
    },
  })
);

server.listen();

This simple server:

✔️ Registers one tool
✔️ Accepts a name argument
✔️ Returns a message response
✔️ Works with any MCP client

🧩 Connecting Your MCP Server to Claude Desktop

{
  "servers": [
    {
      "name": "My MCP Server",
      "type": "websocket",
      "url": "wss://your-public-server.com"
    }
  ]
}

🧩 Connecting to VSCode (MCP Extension)

{
  "mcpServers": {
    "myServer": {
      "command": "node",
      "args": ["./dist/server.js"]
    }
  }
}

Your tools will show up in the MCP panel inside VSCode 📎.

☁️ Deployment Options

🌩️ 1. Cloudflare Workers

Perfect for serverless, instant deployments:

Steps:

Clone example project
Configure wrangler.toml
Run wrangler deploy
Fast, free-tier friendly, globally distributed.

🚀 2. Google Cloud Run

Google published a full tutorial + sample repo:

Cloud Run gives you:

Auto-scaling
Pay-per-request
HTTPS by default

🧱 3. Custom Hosting

Run it anywhere:

EC2
Docker
Kubernetes
PM2 on a VPS
Local dev machine

MCP only requires a transport channel (WebSocket or STDIO).

🎯 Why Build Your Own MCP Server?

💼 Enterprise automation
🛡️ Secure tool access
🔌 Standardized integrations
🧩 One tool layer usable across all AI apps
⚡ Faster development for agentic workflows
🌍 Cloud portability and vendor independence

If you're building AI-powered tools, MCP Servers are the future.

📦 Example Public Repository

Here is a clean, minimal, ready-to-use MCP Server starter repo:

👉 GitHub Example (Community Template):

This repository includes:

TypeScript source code
Example tools
Transport implementation
Scripts for running the server
Instructions for connecting to Claude and VSCode

You can fork it and start adding your own tools immediately.

🎉 Final Thoughts

MCP is transforming how AI apps interact with the real world.
By building your own MCP Server, you unlock:

✨ Secure, structured, AI-driven automation
✨ Native integration with Claude & IDEs
✨ Cloud-ready extensibility
✨ A reusable tool layer for any AI agent

If you want, I can also:

🔧 Build a full boilerplate MCP server repo for you
📘 Write a step-by-step Cloudflare or Cloud Run deployment guide
🧩 Generate architecture diagrams
🎨 Create a cover image for your dev.to article

Just tell me!

📚Enterprise Design Patterns: Table Module with Python Example

Walter Emmanuel Salas Jimenez — Wed, 05 Nov 2025 18:10:26 +0000

📑 Table of Contents

Why Table Module Matters
What is Table Module?
Analogy: The School Office
Python Example: Orders Table
When to Use & When to Avoid
Curiosities & Recommendations
GitHub Repo + Automation
Final Thoughts

🔥 Why Table Module Matters

In enterprise apps, business logic can live in different places:

In the database (stored procedures).
In domain models (one class per row).
Or in a table module: one class per table.

👉 Table Module keeps all rules for a table in a single place, making code easier to read and maintain when logic is simple.

📖 What is Table Module?

Definition:

A single class that handles the business logic for all rows in a database table or view.

⚖️ Difference with Domain Model:

Domain Model → 1 class per row.
Table Module → 1 class per table.

🧩 Analogy: The School Office

Imagine a school secretary’s office:

Instead of every teacher managing attendance (Domain Model),
The office manages attendance records for the whole school (Table Module).

📌 Centralized, consistent, and simple.

💻 Python Example: Orders Table

❌ Without Table Module (spaghetti logic)

import sqlite3

conn = sqlite3.connect(":memory:")
cursor = conn.cursor()
cursor.execute("CREATE TABLE orders (id INTEGER, customer TEXT, total REAL)")
cursor.executemany("INSERT INTO orders VALUES (?, ?, ?)", [
    (1, "Alice", 120.0),
    (2, "Bob", 80.5),
    (3, "Alice", 45.0)
])

# Logic spread everywhere 😓
cursor.execute("SELECT SUM(total) FROM orders WHERE customer='Alice'")
print("Alice total:", cursor.fetchone()[0])

❌ Problem: Logic is scattered in SQL queries all over the app.

✅ With Table Module

import sqlite3

class OrdersTable:
    def __init__(self, connection):
        self.conn = connection

    def total_sales(self):
        cursor = self.conn.cursor()
        cursor.execute("SELECT SUM(total) FROM orders")
        return cursor.fetchone()[0]

    def sales_by_customer(self, customer):
        cursor = self.conn.cursor()
        cursor.execute("SELECT SUM(total) FROM orders WHERE customer=?", (customer,))
        return cursor.fetchone()[0]

# Setup DB
conn = sqlite3.connect(":memory:")
cursor = conn.cursor()
cursor.execute("CREATE TABLE orders (id INTEGER, customer TEXT, total REAL)")
cursor.executemany("INSERT INTO orders VALUES (?, ?, ?)", [
    (1, "Alice", 120.0),
    (2, "Bob", 80.5),
    (3, "Alice", 45.0)
])

# Usage
orders = OrdersTable(conn)
print("Total Sales:", orders.total_sales())
print("Alice Sales:", orders.sales_by_customer("Alice"))

✅ SRP: All business logic lives in OrdersTable.

✅ Reusability: Centralized methods.

✅ KISS: Simple & clean.

🤔 When to Use & When to Avoid

✅ Use Table Module when:

Business rules are simple.
You need reports or aggregations.
Tables are the main unit of work.

❌ Avoid when:

Each row has complex behavior.
You need polymorphism → prefer Domain Model.

🧠 Curiosities & Recommendations

💡 Did you know?

Table Module was a stepping stone before modern ORMs like SQLAlchemy or Django ORM.
Many legacy apps still hide Table Modules inside stored procedures.
Fowler recommends it for reporting systems.

👉 Pro tip: Use Table Module for data-centric apps, Domain Model for behavior-rich apps.

📦 GitHub Repo + Automation

Repo structure:

enterprise-table-module/
├─ table_module.py
├─ tests/
│   └─ test_table_module.py
├─ requirements.txt
└─ .github/
   └─ workflows/
      └─ ci.yml

requirements.txt

pytest==8.3.3

.github/workflows/ci.yml

name: Python CI

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-python@v4
        with:
          python-version: '3.11'
      - run: pip install -r requirements.txt
      - run: pytest

🔗 GitHub Repository Example

🎯 Final Thoughts

The Table Module pattern is a powerful yet underrated way to structure enterprise apps when logic is simple and table-oriented.

✨ Remember:

Use it for reports and aggregations.
Switch to Domain Model when rules grow complex.

✍️ Your turn! Would you use Table Module in your next project?

Let me know in the comments 👇

📚Enterprise Design Patterns: Table Module with Python Example

Walter Emmanuel Salas Jimenez — Wed, 17 Sep 2025 07:02:04 +0000

🚀 In this article, we’ll explore the Table Module pattern from Martin Fowler’s Catalog of Enterprise Application Architecture.

We’ll break it down with analogies, real-world Python code, and a GitHub repo with automation.

📑 Table of Contents

Why Table Module Matters
What is Table Module?
Analogy: The School Office
Python Example: Orders Table
When to Use & When to Avoid
Curiosities & Recommendations
GitHub Repo + Automation
Final Thoughts

🔥 Why Table Module Matters

In enterprise apps, business logic can live in different places:

In the database (stored procedures).
In domain models (one class per row).
Or in a table module: one class per table.

👉 Table Module keeps all rules for a table in a single place, making code easier to read and maintain when logic is simple.

📖 What is Table Module?

Definition:

A single class that handles the business logic for all rows in a database table or view.

⚖️ Difference with Domain Model:

Domain Model → 1 class per row.
Table Module → 1 class per table.

🧩 Analogy: The School Office

Imagine a school secretary’s office:

Instead of every teacher managing attendance (Domain Model),
The office manages attendance records for the whole school (Table Module).

📌 Centralized, consistent, and simple.

💻 Python Example: Orders Table

❌ Without Table Module (spaghetti logic)

import sqlite3

conn = sqlite3.connect(":memory:")
cursor = conn.cursor()
cursor.execute("CREATE TABLE orders (id INTEGER, customer TEXT, total REAL)")
cursor.executemany("INSERT INTO orders VALUES (?, ?, ?)", [
    (1, "Alice", 120.0),
    (2, "Bob", 80.5),
    (3, "Alice", 45.0)
])

# Logic spread everywhere 😓
cursor.execute("SELECT SUM(total) FROM orders WHERE customer='Alice'")
print("Alice total:", cursor.fetchone()[0])

❌ Problem: Logic is scattered in SQL queries all over the app.

✅ With Table Module

import sqlite3

class OrdersTable:
    def __init__(self, connection):
        self.conn = connection

    def total_sales(self):
        cursor = self.conn.cursor()
        cursor.execute("SELECT SUM(total) FROM orders")
        return cursor.fetchone()[0]

    def sales_by_customer(self, customer):
        cursor = self.conn.cursor()
        cursor.execute("SELECT SUM(total) FROM orders WHERE customer=?", (customer,))
        return cursor.fetchone()[0]

# Setup DB
conn = sqlite3.connect(":memory:")
cursor = conn.cursor()
cursor.execute("CREATE TABLE orders (id INTEGER, customer TEXT, total REAL)")
cursor.executemany("INSERT INTO orders VALUES (?, ?, ?)", [
    (1, "Alice", 120.0),
    (2, "Bob", 80.5),
    (3, "Alice", 45.0)
])

# Usage
orders = OrdersTable(conn)
print("Total Sales:", orders.total_sales())
print("Alice Sales:", orders.sales_by_customer("Alice"))

✅ SRP: All business logic lives in OrdersTable.

✅ Reusability: Centralized methods.

✅ KISS: Simple & clean.

🤔 When to Use & When to Avoid

✅ Use Table Module when:

Business rules are simple.
You need reports or aggregations.
Tables are the main unit of work.

❌ Avoid when:

Each row has complex behavior.
You need polymorphism → prefer Domain Model.

🧠 Curiosities & Recommendations

💡 Did you know?

Table Module was a stepping stone before modern ORMs like SQLAlchemy or Django ORM.
Many legacy apps still hide Table Modules inside stored procedures.
Fowler recommends it for reporting systems.

👉 Pro tip: Use Table Module for data-centric apps, Domain Model for behavior-rich apps.

📦 GitHub Repo + Automation

Repo structure:

enterprise-table-module/
├─ table_module.py
├─ tests/
│   └─ test_table_module.py
├─ requirements.txt
└─ .github/
   └─ workflows/
      └─ ci.yml

requirements.txt

pytest==8.3.3

.github/workflows/ci.yml

name: Python CI

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-python@v4
        with:
          python-version: '3.11'
      - run: pip install -r requirements.txt
      - run: pytest

🔗 GitHub Repository Example

🎯 Final Thoughts

The Table Module pattern is a powerful yet underrated way to structure enterprise apps when logic is simple and table-oriented.

✨ Remember:

Use it for reports and aggregations.
Switch to Domain Model when rules grow complex.

✍️ Your turn! Would you use Table Module in your next project?

Let me know in the comments 👇

🧩 Design Principles of Software: Building Better Code with Python

Walter Emmanuel Salas Jimenez — Wed, 17 Sep 2025 05:37:59 +0000

🚀 TL;DR

This article explains key software design principles (SOLID + DRY +
KISS) with a real-world Python example.\
You'll also find step-by-step code, a GitHub repo with automation, and a
short guide to present this as a 5-minute video. 🎥

📌 Outline

Why software design principles matter 🤔\
Key principles (SOLID, DRY, KISS, YAGNI) 📚\
Python example: Order Processing System 🐍\
Refactoring with design principles applied ✨\
GitHub repo structure & CI/CD automation ⚙️

1️⃣ Why software design principles matter 🤔

🔧 Maintainability → Easier to update and fix bugs.\
♻️ Reusability → Write once, use multiple times.\
📈 Scalability → Design that grows with your app.\
👩‍💻 Team collaboration → Principles help everyone understand and extend code.

2️⃣ Core Design Principles 📚

SOLID → Five core OOP principles:
- S: Single Responsibility\
- O: Open/Closed\
- L: Liskov Substitution\
- I: Interface Segregation\
- D: Dependency Inversion
DRY → Don't Repeat Yourself\
KISS → Keep It Simple, Stupid\
YAGNI → You Ain't Gonna Need It

3️⃣ Python Example: Order Processing System 🐍

❌ Bad code (violates SRP, DRY):

class Order:
    def __init__(self, items):
        self.items = items

    def calculate_total(self):
        return sum(item['price'] for item in self.items)

    def save_to_db(self):
        print("Saving order to database...")

    def send_email(self):
        print("Sending email to customer...")

👉 Problem: One class is doing everything (violates SRP).

✅ Refactored code with design principles:

class Order:
    def __init__(self, items):
        self.items = items

    def calculate_total(self):
        return sum(item['price'] for item in self.items)


class OrderRepository:
    def save(self, order: Order):
        print(f"Saving order with total {order.calculate_total()} to database...")


class EmailService:
    def send_order_confirmation(self, order: Order):
        print(f"Email sent for order total: {order.calculate_total()}")


# Usage
items = [{"name": "Pizza", "price": 12}, {"name": "Cola", "price": 3}]
order = Order(items)

repo = OrderRepository()
repo.save(order)

email = EmailService()
email.send_order_confirmation(order)

✅ SRP: Each class has a single responsibility.\
✅ DRY: No duplicate calculation logic.\
✅ KISS: Simple methods and classes.\
✅ Extensible: Swap EmailService with SMS later (Open/Closed
Principle).

4️⃣ Repo Structure & Automation ⚙️

software-design-principles/
├─ order.py
├─ tests/
│   └─ test_order.py
├─ requirements.txt
├─ README.md
└─ .github/
   └─ workflows/
      └─ ci.yml

requirements.txt

pytest==8.3.3

ci.yml (GitHub Actions)

name: Python CI

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-python@v4
        with:
          python-version: '3.11'
      - run: pip install -r requirements.txt
      - run: pytest

🚀Repository link
🔑Repository to Practice

📊 Other Dashboard Tools: Streamlit, Dash, and Bokeh (with deploy and CI/CD)

Walter Emmanuel Salas Jimenez — Mon, 15 Sep 2025 17:26:19 +0000

Quick Summary: In this practical article in Spanish, you'll see three popular alternatives for creating dashboards and reports in Python — Streamlit, Dash y Bokeh — with ready-to-run code examples, step-by-step deployment instructions (including CI/CD with GitHub Actions), a short guide for publishing on Dev.to, and an English script for your presentation video (≤5 min). 🚀

🧭 Índice

Why use these tools?
Streamlit — mini example + simple deploy
Dash (Plotly) — example, Docker and CI/CD to Cloud Run
Bokeh — example and deployment notes (websockets)
Repo structure and requirements.txt
GitHub Actions: pipeline (tests → build → deploy)

1) Why use these tools? 🤔

Streamlit: ultra-fast for interactive prototypes and demos. Ideal for data scientists. ✅
Dash: powerful when you need complex components and fine control (Plotly + Flask). 👍
Bokeh: very good for interactive visualizations and apps that require a server (Bokeh Server). 🏗️

Each tool has trade-offs in ease vs control vs scalability — in this article you'll see minimal examples and how to get them to the cloud.

2) Streamlit — minimal example

Archivo: streamlit_app.py

# streamlit_app.py
import streamlit as st
import pandas as pd
import altair as alt

st.title('Demo: Streamlit - Sales')

df = pd.DataFrame({
    'category': ['A', 'B', 'C', 'A', 'B', 'C'],
    'sales': [10, 15, 7, 12, 9, 20]
})

sel = st.selectbox('Select category', ['All'] + df['category'].unique().tolist())
if sel != 'All':
    df = df[df['category'] == sel]

chart = alt.Chart(df).mark_bar().encode(
    x='category',
    y='sales'
)

st.altair_chart(chart, use_container_width=True)

Run locally:

pip install streamlit pandas altair
streamlit run streamlit_app.py

Deployment tip: The fastest way is to use Streamlit Community Cloud (direct connection with GitHub: you upload your repo and deploy it from share.streamlit.io).

3) Dash (Plotly) — example + Docker + CI/CD (Cloud Run)

File: app.py

# app.py
import os
from dash import Dash, html, dcc
import plotly.express as px
import pandas as pd

# Example data
df = pd.DataFrame({'x': [1, 2, 3, 4], 'y': [10, 5, 8, 12]})
fig = px.line(df, x='x', y='y', title='Dash Example')

app = Dash(__name__)
server = app.server  # exposes the WSGI app for Gunicorn

app.layout = html.Div([
    html.H1('Dash - Demo'),
    dcc.Graph(figure=fig)
])

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 8050)))

requirements.txt (example):

dash
pandas
plotly
gunicorn

Dockerfile (para Cloud Run u otros servicios)

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
# Gunicorn runs the WSGI server exposed in `server`
CMD ["gunicorn", "--bind", ":$PORT", "--workers", "1", "--threads", "8", "--timeout", "0", "app:server"]

GitHub Actions → Build & Deploy to Google Cloud Run

Save this workflow to .github/workflows/deploy-cloudrun.yml:

name: CI/CD - Cloud Run
on:
  push:
    branches: [ main ]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Configure GCloud
        uses: google-github-actions/setup-gcloud@v1
        with:
          service_account_key: ${{ secrets.GCP_SA_KEY }}
          project_id: ${{ secrets.GCP_PROJECT_ID }}

      - name: Build and push image (Cloud Build)
        run: |
          gcloud builds submit --tag gcr.io/${{ secrets.GCP_PROJECT_ID }}/dash-app:$GITHUB_SHA

      - name: Deploy to Cloud Run
        uses: google-github-actions/deploy-cloudrun@v1
        with:
          service: dash-app
          image: gcr.io/${{ secrets.GCP_PROJECT_ID }}/dash-app:$GITHUB_SHA
          region: us-central1

✅ What it does: On every push to main, the workflow builds the image, uploads it to Google Container Registry, and deploys a new revision to Cloud Run.

4) Bokeh — minimal example and deployment notes

File: main.py (Bokeh server)

# main.py
from bokeh.plotting import figure
from bokeh.io import curdoc

p = figure(title='Bokeh demo')
p.line([1, 2, 3, 4], [3, 7, 8, 5])

curdoc().add_root(p)

Run locally (Bokeh server):

pip install bokeh
bokeh serve --show main.py

Deployment notes:

Bokeh uses websockets (Bokeh Server). When deploying, ensure your service supports timeouts and websocket connections.
Typical strategy: create a Dockerfile with bokeh serve --port $PORT --allow-websocket-origin='*' main.py and deploy to Cloud Run (or similar).
If using Cloud Run, configure a higher timeout for long connections.

5) Recommended structure

my-dashboard/
├─ streamlit_app.py
├─ app.py          # dash
├─ main.py         # bokeh
├─ requirements.txt
├─ Dockerfile      # for dash/bokeh if using container
└─ .github/
   └─ workflows/
      └─ deploy-cloudrun.yml

6) GitHub Actions: suggested pipeline (details)

Test → Run pytest or quick checks (flake8, mypy).
Build → Build Docker image or run gcloud builds submit.
Deploy → gcloud run deploy or use google-github-actions/deploy-cloudrun.

🔗 GitHub Repository

The full code with Streamlit, Dash, and Bokeh examples, along with the Dockerfile and CI/CD workflows with GitHub Actions, is available in the following repository:

👉 GitHub Repository: my-dashboard

🚀 Applying API Testing Frameworks: Real-World Examples with Code

Walter Emmanuel Salas Jimenez — Thu, 05 Jun 2025 19:37:46 +0000

API testing is a cornerstone of modern software quality assurance. Whether you're testing RESTful services or SOAP endpoints, having the right framework in your toolbox can make all the difference. In this post, we'll explore how to apply popular API testing frameworks, show real-world examples, and point you to great learning resources, including videos and documentation.

💡 If you're still evaluating API testing tools, check out this comparison article:Top 10 API Testing Tools

📌 Why API Testing Matters

✅ Detects defects early
✅ Ensures contract compliance
✅ Supports automation pipelines
✅ Works independently of the UI

Frameworks like Postman, REST Assured, Karate, Supertest, and Newman offer varied features like scripting, CI/CD integration, and mocking support.

🔧 1. REST Assured (Java)
Best for: Java-based automation frameworks
Supports: RESTful APIs

✨ Setup (Maven)

<dependency>
    <groupId>io.rest-assured</groupId>
    <artifactId>rest-assured</artifactId>
    <version>5.3.0</version>
    <scope>test</scope>
</dependency>

✅ Sample Test

import io.restassured.RestAssured;
import org.junit.jupiter.api.Test;

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

class APITest {

    @Test
    void checkUserAPI() {
        RestAssured.baseURI = "https://jsonplaceholder.typicode.com";

        given()
            .when()
            .get("/users/1")
            .then()
            .statusCode(200)
            .body("username", equalTo("Bret"));
    }
}

📘 Docs: rest-assured.io
🎥 Video: REST Assured Full Course (YouTube)

🥋 2. Karate DSL (Java / DSL)
Best for: BDD-style testing
Supports: REST, SOAP, GraphQL, gRPC
_
✨ Setup (Maven)_

<dependency>
  <groupId>com.intuit.karate</groupId>
  <artifactId>karate-junit5</artifactId>
  <version>1.4.1</version>
  <scope>test</scope>
</dependency>

✅ Feature File Example

Feature: Get a single user

Scenario: Validate user details
  Given url 'https://jsonplaceholder.typicode.com/users/1'
  When method GET
  Then status 200
  And match response.username == 'Bret'

📘 Docs: karatelabs.io
🎥 Video: Karate DSL Tutorial (YouTube)

🧪 3. Supertest (JavaScript)
Best for: Node.js apps
Works with: Express.js, Mocha, Jest

✨ Install

npm install --save-dev supertest jest

✅ Sample Test (with Jest)

const request = require('supertest');
const app = require('../app'); // Your Express app

describe('GET /users/1', () => {
  it('should return a user', async () => {
    const res = await request(app).get('/users/1');
    expect(res.statusCode).toBe(200);
    expect(res.body.username).toBe('Bret');
  });
});

📘 Docs: Supertest GitHub

📫 4. Postman + Newman (JavaScript)
Best for: Manual + Automated tests
Newman: CLI runner for Postman collections

✅ Use Case: CI/CD Integration

Create your collection in Postman.
Export as collection.json.
Run in CI pipeline:

newman run collection.json

📘 Docs: Newman CLI
🎥 Video: Postman + Newman CI Tutorial

🛠️ Bonus: Best Practices

🔁 Use data-driven tests (CSV, JSON)
🔐 Secure sensitive data (use .env files or vaults)
🧪 Automate in CI/CD using GitHub Actions, GitLab CI, Jenkins
📄 Generate reports (Allure, Newman HTML Reporter)

🙌 Final Thoughts
API testing is no longer optional—it's essential. Start small, automate progressively, and pick a framework that aligns with your team’s tech stack and workflow. Whether you're coding in Java or JavaScript, there's a tool to fit your needs.

If you liked this article, don’t forget to:

👉 Bookmark it
🗣️ Share it with your QA/dev team
💬 Comment your favorite API testing tool

🔐IaC Security Made Easy with Horusec: A SAST Approach🚀

Walter Emmanuel Salas Jimenez — Mon, 21 Apr 2025 02:23:18 +0000

🧩 Introduction
Infrastructure as Code (IaC) has transformed how teams provision and manage infrastructure. By treating infrastructure configurations like code, we gain consistency, speed, and repeatability. However, with this agility comes the responsibility of securing that code — just like we do with traditional application code. That’s where SAST tools come in. In this article, we’ll explore how to apply Static Application Security Testing (SAST) using Horusec to scan IaC codebases and keep your infrastructure safe 🛡️.

In this article, we’ll learn how to:

Set up Horusec to scan any IaC codebase.
Apply it locally and in CI/CD.
Use it with other SAST tools.
Automate reporting and exports.

💡 What is Horusec?
Horusec is a powerful, open-source security tool that performs static analysis across multiple languages and IaC formats (like Terraform and Kubernetes YAML files). It's designed to find vulnerabilities before code reaches production 🏭.

⚙️ Key Features:

🌐 Multi-language & IaC support (Terraform, Dockerfile, YAML, etc.)
🔄 CI/CD integration with GitHub Actions, GitLab CI, Jenkins, and others
📊 Clear vulnerability reports with severity levels and recommendations
🧠 Developer-friendly: runs locally or in pipelines without complex setup

📥 Installing Horusec CLI
You can install Horusec using a simple script:

curl -fsSL https://raw.githubusercontent.com/ZupIT/horusec/main/deployments/scripts/install.sh | bash -s latest

Or via Docker 🐳:

docker run -v /var/run/docker.sock:/var/run/docker.sock -v $(pwd):/src horuszup/horusec-cli:latest horusec start -p

🔍 Scanning Infrastructure as Code
Once installed, scanning your code is as easy as running:

horusec start -p .

Horusec will inspect all supported files in the current directory and display a summary of issues found 📋.

⚡ Integrating into CI/CD (GitHub Actions Example)

Let’s automate this! Here's how to run Horusec as part of your GitHub Actions pipeline:

name: Horusec Security Scan
on:
push: branches: [ main ] pull_request: branches: [ main ]

jobs: horusec_scan: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Install Horusec run: | curl -fsSL https://raw.githubusercontent.com/ZupIT/horusec/main/deployments/scripts/install.sh | bash -s latest
- name: Run Horusec Scan run: | horusec start -p . -e="true"

This setup scans your repo on every push or pull request to main, helping you catch security issues early 🚨.

🧪 Example: Terraform (Without docker)
You can see the example in my repository on Github.

👉horusec-iac-demo

Just run horusec start -p . and let it detect issues like:

Hardcoded secrets 🔑
Insecure resource definitions 🔓
Misconfigured ports or permissions 🔐

📊 Analyzing the Results
Horusec categorizes vulnerabilities by severity:

🟥 Critical
🟧 High
🟨 Medium
🟩 Low
🟦 Info

Each issue includes:

File and line number 📍
Description and recommendation 📘
CWE ID (Common Weakness Enumeration) for deeper learning 🔍

📊 Reports & Outputs
Horusec supports multiple output formats:

json – for custom parsing or dashboards.
html – for visual inspection.
sarif – compatible with GitHub Security tab.

Example to export an HTML report:

horusec start -p . -o html -O report.html
Open report.html in any browser to see a full security summary.

✅ Best Practices

🔁 Run Horusec on each commit or pull request
🚫 Block merge if critical vulnerabilities are found
📚 Train your team to understand IaC security risks
🧩 Use Horusec alongside other tools (e.g., Snyk, Checkov)

🔗 References

🧠 Conclusion
IaC enables rapid infrastructure deployment — but speed without security is a recipe for risk. Using Horusec as part of your SAST approach allows you to catch vulnerabilities early, automate scans, and ensure compliance across your entire infrastructure pipeline. Give it a try and secure your code from commit to cloud 🌩️🔒

Have you tried it yet? Got any questions? Drop them in the comments below — I’d love to hear from you! 👇

🛡️ Scan and Protect Any App in 5 Minutes with Bearer CLI (SAST for Everyone)

Walter Emmanuel Salas Jimenez — Sun, 20 Apr 2025 18:43:33 +0000

Applying security testing to your application shouldn't be complicated. In this guide, I’ll show you how to use a powerful tool called Bearer CLI to run static application security tests (SAST) easily, efficiently, and with compatibility for almost any application.

🧠 What is SAST?
SAST (Static Application Security Testing) is a technique for analyzing the source code of an application to find vulnerabilities without executing it. It’s a key part of any modern DevSecOps pipeline.

With SAST, you can detect:

SQL Injection
XSS (Cross-site Scripting)
Sensitive data leaks
Insecure use of libraries, and more.

🐻 What is Bearer CLI?
Bearer CLI is an open-source tool that scans your code for security vulnerabilities and privacy issues. Unlike many SAST tools that require complex configuration, Bearer CLI works right out of the box via your terminal—no initial setup required.

✅ Open Source
✅ Supports multiple languages (JavaScript, TypeScript, Java, Ruby, etc.)
✅ Easy integration with CI/CD pipelines (GitHub Actions, GitLab CI, etc.)

🚀 How to Install Bearer CLI
Install using Homebrew (on macOS or Linux):

brew install bearer/tap/bearer
Or use the official install script:
curl -sfL https://raw.githubusercontent.com/Bearer/bearer/main/install.sh | sh

🛠️ Scan Your Application
Once installed, navigate to the root of your project and simply run:

bearer scan .

This command scans your codebase and prints a vulnerability report directly in your terminal.

🔍 Example usage:

cd ~/mis-proyectos/mi-app
bearer scan .

🧩 Practical Example

See a working demo in this GitHub repository:

Example Bearer CLI

📦 CI/CD Integration
To run Bearer automatically in your CI pipelines, add it as a step in your GitHub Actions .yml file:

- name: Scan with Bearer run: | curl -sfL https://raw.githubusercontent.com/Bearer/bearer/main/install.sh | sh ./bin/bearer scan .

Or in GitLab CI/CD:

sast_scan: script: - curl -sfL https://raw.githubusercontent.com/Bearer/bearer/main/install.sh | sh - ./bin/bearer scan .

📁 Custom Reports
Export results in JSON or SARIF format to integrate with GitHub Security or other tools:

bearer scan . --format sarif > resultado.sarif

🌐 Resources & References

🌍 Official Bearer CLI Site: https://www.bearer.com/cli
📚 Full Documentation: https://docs.bearer.com/cli
🧰 GitHub Repository: https://github.com/Bearer/bearer

🎥 Video: Bearer CLI en acción
Prefer to learn visually? Check out this awesome video tutorial:

👉 fix your code with Bearer with one click
(YouTube)
(📽️ Duration: 14 minutes – super clear and straight to the point!)

✅ Conclusion
With tools like Bearer CLI, security doesn't have to be hard or expensive. Adding SAST scans to your workflow is now just a matter of minutes.

Have you tried it yet? Got any questions? Drop them in the comments below — I’d love to hear from you! 👇

Forem: Walter Emmanuel Salas Jimenez

🔭 Observability Practices: The 3 Pillars with a Node.js + OpenTelemetry Example

🚀 Demystifying Observability: A Practical Guide with Node.js, OpenTelemetry, Prometheus, and Grafana

What is Observability?

Why Observability Matters

🛠️ Practical Example: Observability with Node.js and OpenTelemetry

The Observability Stack

Step 1: Instrumenting the Node.js API

1. OpenTelemetry Tracing Setup (app/src/tracer.js)

2. Custom Metrics (app/src/metrics.js)

Step 2: Orchestration with Docker Compose

Step 3: Seeing the README.md of the repository.

Conclusion

🚀 Build a Remote MCP Server That Connects to Any MCP Client (Claude, VSCode & More)

🧠 What Is an MCP Server?

🔌 How MCP Servers Connect to Clients

🛠️ Minimal MCP Server Example (TypeScript)

🧩 Connecting Your MCP Server to Claude Desktop

🧩 Connecting to VSCode (MCP Extension)

Your tools will show up in the MCP panel inside VSCode 📎.

☁️ Deployment Options

🌩️ 1. Cloudflare Workers

🚀 2. Google Cloud Run

🧱 3. Custom Hosting

MCP only requires a transport channel (WebSocket or STDIO).

🎯 Why Build Your Own MCP Server?

If you're building AI-powered tools, MCP Servers are the future.

📦 Example Public Repository

You can fork it and start adding your own tools immediately.

🎉 Final Thoughts

📚Enterprise Design Patterns: Table Module with Python Example

📑 Table of Contents

🔥 Why Table Module Matters

📖 What is Table Module?

🧩 Analogy: The School Office

💻 Python Example: Orders Table

❌ Without Table Module (spaghetti logic)

✅ With Table Module

🤔 When to Use & When to Avoid

🧠 Curiosities & Recommendations

📦 GitHub Repo + Automation

🎯 Final Thoughts

📚Enterprise Design Patterns: Table Module with Python Example

📑 Table of Contents

🔥 Why Table Module Matters

📖 What is Table Module?

🧩 Analogy: The School Office

💻 Python Example: Orders Table

❌ Without Table Module (spaghetti logic)

✅ With Table Module

🤔 When to Use & When to Avoid

🧠 Curiosities & Recommendations

📦 GitHub Repo + Automation

🎯 Final Thoughts

🧩 Design Principles of Software: Building Better Code with Python

🚀 TL;DR

📌 Outline

1️⃣ Why software design principles matter 🤔

2️⃣ Core Design Principles 📚

3️⃣ Python Example: Order Processing System 🐍

❌ Bad code (violates SRP, DRY):

✅ Refactored code with design principles:

4️⃣ Repo Structure & Automation ⚙️

📊 Other Dashboard Tools: Streamlit, Dash, and Bokeh (with deploy and CI/CD)

🧭 Índice

1) Why use these tools? 🤔

2) Streamlit — minimal example

3) Dash (Plotly) — example + Docker + CI/CD (Cloud Run)

Dockerfile (para Cloud Run u otros servicios)

GitHub Actions → Build & Deploy to Google Cloud Run

4) Bokeh — minimal example and deployment notes

5) Recommended structure

6) GitHub Actions: suggested pipeline (details)

🔗 GitHub Repository

🚀 Applying API Testing Frameworks: Real-World Examples with Code

🔐IaC Security Made Easy with Horusec: A SAST Approach🚀

🛡️ Scan and Protect Any App in 5 Minutes with Bearer CLI (SAST for Everyone)

1. OpenTelemetry Tracing Setup (`app/src/tracer.js`)