README.md

WebHook Tester

This application allows you to test and debug Webhooks and HTTP requests using unique (random) URLs. You can customize the response code, content-type HTTP header, response content and set some delay for the HTTP responses. The main idea is viewed here.

This application is written in GoLang and works very fast. It comes with a tiny UI (written in Vue.js), which is built in the binary file, so you don't need any additional assets for the application using. Websockets are also used for incoming webhook notifications in the UI - you don't need any 3rd party solutions (like pusher.com) for this!

🔥 Features list

• Liveness/readiness probes (routes /live and /ready respectively)
• Can be started without any 3rd party dependencies
• Metrics in prometheus format (route /metrics)
• Built-in tiny and fast UI, based on vue.js
• Multi-arch docker image, based on scratch
• Unprivileged user in docker image is used
• Well-tested and documented source code
• Built-in CLI health check sub-command
• Recorded request binary view using UI
• JSON/human-readable logging formats
• Customizable webhook responses
• Built-in Websockets support
• Low memory/cpu usage
• Free and open-source
• Ready to scale

📷 Screenshots

Dashboard	Request details	Help screen	Session options

🗃 Storage

At the moment 2 types of data storage are supported - memory and redis server (flag --storage-driver).

The memory driver is useful for fast local debugging when recorded requests will not be needed after the app stops. The Redis driver, on the contrary, stores all the data on the redis server, and the data will not be lost after the app restarts. When running multiple app instances (behind the load balancer), it is also necessary to use the redis driver.

📢 Pub/sub

Publishing/subscribing are used to send notifications using WebSockets, and it also supports 2 types of driver - memory and redis server (flag --pubsub-driver).

For multiple app instances redis driver must be used.

🧩 Installation

Download the latest binary file for your arch (to run on macOS use the linux/arm64 platform) from the releases page. For example, let's install it on amd64 arch (e.g.: Debian, Ubuntu, etc):

$ curl -SsL -o ./webhook-tester https://github.com/tarampampam/webhook-tester/releases/latest/download/webhook-tester-linux-amd64
$ chmod +x ./webhook-tester

# optionally, install the binary file globally:
$ sudo install -g root -o root -t /usr/local/bin -v ./webhook-tester
$ rm ./webhook-tester
$ webhook-tester --help

Additionally, you can use the docker image:

Registry	Image
GitHub Container Registry	ghcr.io/tarampampam/webhook-tester
Docker Hub	tarampampam/webhook-tester

Using the latest tag for the docker image is highly discouraged because of possible backward-incompatible changes during major upgrades. Please, use tags in X.Y.Z format

⚙ Usage

This application supports the following sub-commands:

Sub-command	Description
serve	Start HTTP server
healthcheck	Health checker for the HTTP server (use case - docker healthcheck)

And global flags:

Flag	Description
--version, -v	Display application version
--verbose	Verbose output
--debug	Debug output
--log-json	Logs in JSON format

🖥 HTTP server starting

serve sub-command allows to use next flags:

Flag	Description	Default value	Environment variable
--listen, -l	IP address to listen on	0.0.0.0 (all interfaces)	LISTEN_ADDR
--port, -p	TCP port number	8080	LISTEN_PORT or PORT
--create-session	Create a session on server startup with this UUID (example: 00000000-0000-0000-0000-000000000000)		CREATE_SESSION
--storage-driver	Storage engine (memory or redis)	memory	STORAGE_DRIVER
--pubsub-driver	Pub/Sub engine (memory or redis)	memory	PUBSUB_DRIVER
--redis-dsn	Redis server DSN (required if storage or pub/sub driver is redis)	redis://127.0.0.1:6379/0	REDIS_DSN
--ignore-header-prefix	Ignore incoming webhook header prefix (case insensitive; example: X-Forwarded-)	[]
--max-request-body-size	Maximal webhook request body size (in bytes; 0 = unlimited)	65536
--max-requests	Maximum stored requests per session (max 65535)	128	MAX_REQUESTS
--session-ttl	Session lifetime (examples: 48h, 1h30m)	168h	SESSION_TTL
--ws-max-clients	Maximal websocket clients (0 = unlimited)	0	WS_MAX_CLIENTS
--ws-max-lifetime	Maximal single websocket lifetime (examples: 3h, 1h30m; 0 = unlimited)	0	WS_MAX_LIFETIME

Redis DSN format: redis://<user>:<password>@<host>:<port>/<db_number>

Server starting command example:

$ ./webhook-tester --log-json serve \
    --port 8080 \
    --storage-driver redis \
    --pubsub-driver redis \
    --redis-dsn redis://redis-host:6379/0 \
    --max-requests 512 \
    --ignore-header-prefix X-Forwarded- \
    --ignore-header-prefix X-Reverse-Proxy- \
    --create-session 00000000-0000-0000-0000-000000000000 \
    --ws-max-clients 30000 \
    --ws-max-lifetime 6h

After that you can navigate your browser to http://127.0.0.1:8080/ try to send your first HTTP request for the webhook-tester!

🐋 Using docker

Just execute in your terminal:

$ docker run --rm -p 8080:8080/tcp tarampampam/webhook-tester serve

Docker-compose

For running this app using docker-compose and if you want to keep the data after restarts, you can use the following example with a Redis server as a backend for the data:

version: '3.8'

volumes:
  redis-data: {}

services:
  webhook-tester:
    image: tarampampam/webhook-tester
    command: --log-json serve --port 8080 --storage-driver redis --pubsub-driver redis --redis-dsn redis://redis:6379/0
    ports: ['8080:8080/tcp'] # Open <http://127.0.0.1:8080>
    depends_on:
      redis: {condition: service_healthy}

  redis:
    image: redis:7-alpine
    volumes: [redis-data:/data:rw]
    ports: ['6379/tcp']
    healthcheck:
      test: ['CMD', 'redis-cli', 'ping']
      interval: 1s

Or you can use in-memory data storage only:

version: '3.8'

services:
  webhook-tester:
    image: tarampampam/webhook-tester
    command: serve --port 8080 --create-session 00000000-0000-0000-0000-000000000000
    ports: ['8080:8080/tcp'] # Open <http://127.0.0.1:8080/#/00000000-0000-0000-0000-000000000000>

Support

If you find any package errors, please, make an issue in current repository.

License

This is open-sourced software licensed under the MIT License.