XML Tag Counter: A PowerShell Script That Saved Me Hours (And Can Save You Too!)

Spiros Vatikiotis — Wed, 28 Jan 2026 12:06:52 +0000

I needed to count tags across 200+ XML files containing thousands and thousands of rows. Opening each file and searching manually would take hours. So I built a PowerShell script to do it.
XML Tag Counter scans a directory, counts occurrences of a specific XML tag across all XML files, and gives you totals plus a per-file breakdown.

It handles namespaces, supports multiple file extensions, and shows progress for large batches.

I use it for data migrations, compliance checks, and debugging. It’s saved me a lot of time.

It scans recursively, handles namespaces, and shows progress. No configuration needed.

This is a starting point, and I’d love your help. Found a bug? Have an idea? Want to improve docs or performance? Every contribution helps, whether it’s a small fix or a new feature.

If this script saves you time, consider contributing. Don't forget to tell me what you think after you try it!

Check it out: GitHub Repository

Happy coding ya all!

S.V

Streamline Your Multi-Service Docker applications with wait-for-service.sh

Spiros Vatikiotis — Wed, 14 May 2025 22:12:53 +0000

When dealing with microservices and containerized applications, it's common to face the issue where one service depends on another to be fully operational before it can start. This often leads to timing issues and can disrupt your application’s startup process.

In this post, we will explore how to streamline this problem using a simple but powerful tool called wait-for-service.sh. This script helps ensure that dependent services are fully up and ready before launching your own service.

We'll walk through setting up wait-for-service.sh in a Docker Compose environment, providing a seamless way to wait for your services to be ready.

The Problem
Imagine you have a set of services, with one or more depending on others to function properly. For example, you might have a service that needs to connect to a database, an authentication service, or any other backend service that takes a while to start. Without a tool like wait-for-service.sh, you'd be left with either time-based delays (where the service attempts to connect before the other service is ready) or failures on startup due to missing dependencies.

The goal here is to ensure that your service doesn’t try to connect to another service until that service is fully ready to handle requests.

What is wait-for-service.sh?
wait-for-service.sh is a script designed to block the startup of your service until a dependent service becomes available. It checks if the service is reachable at a given port and waits until it is ready, helping to avoid race conditions during container startup.

You can find the original wait-for-service.sh script in this GitHub repository.

How to Use wait-for-service.sh in Docker Compose
Let’s walk through a practical example using Docker Compose.

Step 1: Create the docker-compose.yml File
Here’s a simple example of a docker-compose.yml file with multiple services where one service (analytics-service) depends on another (keycloack-service).

version: '3.8'

services:
nginx:
container_name: nginx
image: nginx:alpine
ports:
- "8081:80"
- "443:443"
volumes:
- ./nginx:/etc/nginx
networks:
- example-network

analytics-service:
container_name: analytics-service
image: analytics-service:latest
build:
context: ./analytics-service
ports:
- "3001:8080"
depends_on:
- keycloak-service
command: >
sh -c "./scripts/wait-for-service.sh keycloak-service:8080 -- java -jar /app/analytics-service.jar"
networks:
- example-network

keycloak-service:
container_name: keycloak-service
image: keycloak:latest
ports:
- "7000:8080"
environment:
- KEYCLOAK_ADMIN=admin
- KEYCLOAK_ADMIN_PASSWORD=admin
networks:
- example-network

networks:
example-network:
driver: bridge

Step 2: Add the wait-for-service.sh Script
Download the wait-for-service.sh script from the official repository and place it in a scripts/ directory in your project:

Step 3: Run the Services
Once you have everything set up, you can simply run the following command to start your services:

docker-compose up -d

Step 4: Check the Logs
To verify that everything is working as expected, you can check the logs of the analytics-service:

docker logs -f analytics-service

Why is This Useful?
Prevents race conditions: Ensures that dependent services are fully ready before another service tries to connect to them.

Improves startup reliability: Reduces the chances of services failing due to unavailable dependencies at startup.

Simple to implement: You can integrate wait-for-service.sh in your existing Docker Compose setup with minimal configuration changes.

Conclusion
In this post, we demonstrated how to use wait-for-service.sh to manage service dependencies in Docker Compose environments. By using this script, you can easily control the order of service startup and prevent errors that arise from services attempting to connect before their dependencies are ready.

If you're interested in learning more about Docker Compose and microservices architectures, feel free to check out other tutorials or follow along with this GitHub repository.

Feel free to adapt this post as needed. Happy coding! 🚀

S.V

DEV Community: Spiros Vatikiotis

XML Tag Counter: A PowerShell Script That Saved Me Hours (And Can Save You Too!)

Streamline Your Multi-Service Docker applications with wait-for-service.sh

[Boost]

🤯 8 APIs to Make your Next Project 10x better ⚡️

Arindam Majumder ・ Jan 28