worker/core Documentation

Enterprise Ready

Powerful Features

Built with modern development practices, our worker system delivers enterprise-grade performance, reliability, and scalability.

High Performance

Optimized worker processes achieving sub-50ms latency with minimal overhead and maximum throughput.

Smart Queue Management

Advanced queue system with priority levels, automatic retries, and dead-letter queue handling for reliability.

Enterprise Security

Built-in security features including encryption, access controls, and secure task execution isolation.

Advanced Monitoring

Real-time metrics, health checks, and performance monitoring with Prometheus integration.

Extensible Architecture

Flexible plugin system supporting custom workers, middleware, and third-party service integration.

Intelligent Recovery

Self-healing system with automatic failure detection, recovery, and task redistribution.

Developer Friendly

Quick Overview

The UDX Worker system provides a robust foundation for handling background tasks, job queues, and scheduled operations in your applications. Built with modern development practices and optimized for performance.

Advanced Task Management

Efficient handling of background tasks with priority queuing, rate limiting, and intelligent scheduling.

Flexible Job Scheduling

Comprehensive scheduling system with cron expressions, intervals, and timezone support for global operations.

Real-time Performance Metrics

Comprehensive monitoring with Prometheus integration, health checks, and performance tracking dashboard.

worker.js

// Initialize worker with configuration

const worker = new UDXWorker({ queues: ['high', 'default', 'low'], concurrency: 5, retries: 3, timeout: 30000 });

// Add a job to the high-priority queue

worker.addJob('process-video', { url: 'video.mp4', options: { quality: 'high', format: 'mp4' }, priority: 'high' });

System Design

Worker Architecture

Explore the robust architecture and core components that power UDX Worker's enterprise-grade performance.

Container Architecture

Built on an optimized Alpine Linux base image, our container architecture includes:

Advanced process management with Supervisor 4.2
Distributed worker daemon with service mesh support
Schema-validated configuration system
Vault-compatible secrets management

Core Components

Process Orchestration

Advanced service lifecycle management with distributed tracing

Configuration Management

Dynamic configuration with real-time validation and hot reload

Security Framework

Enterprise-grade security with mTLS, RBAC, and secrets rotation

Process Management

Our advanced process management system provides enterprise-grade service orchestration:

Health Monitoring

Real-time health checks with Prometheus integration and alerting

Intelligent Recovery

Smart process recovery with failure analysis and circuit breaking

Advanced Logging

Structured logging with ELK stack integration and retention policies

CLI Management

Powerful CLI with process control, metrics, and debugging tools

Security Principles

Built with security-first design following zero trust architecture principles.

Learn about Zero Trust

Access Control

Non-root execution by default with precise permission controls:

Least privilege principle enforcement
Role-based access control
Fine-grained permission mapping
Secure service isolation

Process Isolation

Complete process isolation using Linux namespaces:

Network namespace isolation
Mount namespace separation
PID namespace containment
IPC namespace segregation

Secret Management

Integrated secret management with multiple provider support:

AWS Secrets Manager

Cloud-native secrets management

Azure Key Vault

Enterprise secret storage

Google Cloud Secrets

GCP secrets management

Bitwarden

Open-source secret manager

Security Features

Encryption at rest
Secure transit
Access auditing
Version control

Authentication

Multi-factor authentication support
Token-based access control
Service account isolation

Network Security

Network policy enforcement
TLS encryption by default
Service mesh integration

Runtime Security

Resource isolation
Secure compute profiles
Vulnerability scanning

Monitoring & Logging

Comprehensive monitoring and logging solutions for UDX Worker

Metrics Collection

Configure Prometheus metrics collection with automatic service discovery:

Available Metrics

System Metrics

CPU Usage
Memory Usage
Disk I/O

Service Metrics

Request Latency
Error Rates
Custom Metrics

Prometheus Configuration

prometheus.yml

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'udx-worker'
    static_configs:
      - targets: ['localhost:9090']
    metrics_path: /metrics
    scheme: http
    relabel_configs:
      - source_labels: [__meta_docker_container_name]
        regex: '/(.*)'
        target_label: container_name
      - source_labels: [__meta_docker_container_label_com_docker_compose_service]
        target_label: service
    metric_relabel_configs:
      - source_labels: [container_name]
        regex: '(.+)'
        target_label: instance

Scrape Settings

15s intervals for fresh metrics

Auto Labeling

Smart container discovery

Structured Logging

Implement structured JSON logging for enhanced searchability and analysis

Logger Configuration

logger.js

const winston = require('winston');
const _ = require('lodash');

const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json(),
    winston.format.metadata({
      fillExcept: ['message', 'level', 'timestamp']
    })
  ),
  defaultMeta: {
    service: 'udx-worker',
    version: process.env.VERSION || 'dev'
  },
  transports: [
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(),
        winston.format.simple()
      )
    }),
    new winston.transports.File({
      filename: '/var/log/udx/error.log',
      level: 'error'
    }),
    new winston.transports.File({
      filename: '/var/log/udx/combined.log'
    })
  ]
});

Log Levels

error, warn, info, debug

Output Formats

JSON & Console friendly

Log Aggregation

Centralize logs with Fluentd for efficient analysis and storage

Fluentd Configuration

fluent.conf


  @type tail
  path /var/log/udx/*.log
  pos_file /var/log/udx/td-agent.pos
  tag udx.*
  
    @type json
    time_key timestamp
    time_format %Y-%m-%dT%H:%M:%S.%NZ
    keep_time_key true
  



  @type elasticsearch
  host elasticsearch
  port 9200
  logstash_format true
  logstash_prefix udx
  flush_interval 5s
  retry_limit 17
  retry_wait 1s
  buffer_chunk_limit 2M
  buffer_queue_limit 32
  type_name _doc

Storage

Elasticsearch optimized

Buffer Settings

Reliable delivery

Alert Configuration

Memory Alerts

alerts.yml

groups:
- name: memory
  rules:
  - alert: HighMemoryUsage
    expr: |
      container_memory_usage_bytes
      / container_spec_memory_limit_bytes
      * 100 > 85
    for: 5m
    labels:
      severity: warning
      type: resource
    annotations:
      summary: High memory usage ({{ $value }}%)
      description: Container using >85% of memory limit

Threshold

Triggers at 85% memory usage

CPU Alerts

alerts.yml

groups:
- name: cpu
  rules:
  - alert: HighCPUUsage
    expr: |
      sum(rate(container_cpu_usage_seconds_total[5m]))
      / count(node_cpu_seconds_total{mode="idle"})
      * 100 > 80
    for: 5m
    labels:
      severity: warning
      type: resource
    annotations:
      summary: High CPU usage ({{ $value }}%)
      description: Container CPU usage >80%

Evaluation

5-minute rate calculation

Network Alerts

alerts.yml

groups:
- name: network
  rules:
  - alert: HighNetworkLatency
    expr: |
      histogram_quantile(0.95,
        rate(http_request_duration_seconds_bucket[5m]))
      > 2
    for: 5m
    labels:
      severity: warning
      type: performance
    annotations:
      summary: High network latency (p95 > 2s)
      description: 95th percentile latency exceeds 2s

Performance

p95 latency monitoring

View Documentation GitHub Repository

Troubleshooting & Debugging

Essential tools and techniques for diagnosing and resolving issues

Diagnostic Commands

Essential commands for diagnosing common issues:

Service Status Check

shell

# Check service status
supervisorctl status

# View service logs
tail -f /var/log/udx/service-name.log

# Check resource usage
docker stats udx-worker

# Inspect configuration
docker exec udx-worker cat /etc/udx/config/worker.yaml

# View process tree
docker top udx-worker

Common Issues

Service Won't Start

Check logs for configuration errors and ensure all dependencies are available.

High Memory Usage

Review resource limits and check for memory leaks in application code.

Slow Performance

Monitor CPU usage and network connectivity issues.

Debug Mode Configuration

Enable debug mode for detailed logging and diagnostics:

Debug Configuration

worker.yaml

debug:
  enabled: true
  verbosity: 3
  trace:
    enabled: true
    sampling: 0.1
  profiling:
    enabled: true
    port: 6060
  metrics:
    detailed: true
    interval: 5s

Debug API Endpoints

curl

# Get debug information
curl http://localhost:6060/debug/vars

# CPU profile (30s sample)
curl http://localhost:6060/debug/pprof/profile

# Memory heap profile
curl http://localhost:6060/debug/pprof/heap

# Goroutine stack traces
curl http://localhost:6060/debug/pprof/goroutine

Info Level

{
  "level": "info",
  "ts": "2025-02-14T15:04:05.000Z",
  "msg": "Service started",
  "service": "web",
  "port": 3000
}

Warning Level

{
  "level": "warn",
  "ts": "2025-02-14T15:04:05.000Z",
  "msg": "High memory usage",
  "service": "web",
  "memory_mb": 512
}

Error Level

{
  "level": "error",
  "ts": "2025-02-14T15:04:05.000Z",
  "msg": "Connection failed",
  "service": "db",
  "error": "timeout"
}

Debugging Tools

gops

Process and stack trace inspection tool

panicparse

Stack trace parser and analyzer

zap

Structured logging with debugging

delve

Source level debugger

Powerful Background Processing

Powerful Features

High Performance

Smart Queue Management

Enterprise Security

Advanced Monitoring

Extensible Architecture

Intelligent Recovery

Quick Overview

Advanced Task Management

Flexible Job Scheduling

Real-time Performance Metrics

Worker Architecture

Container Architecture

Core Components

Process Orchestration

Configuration Management

Security Framework

Process Management

Health Monitoring

Intelligent Recovery

Advanced Logging

CLI Management

Security Principles

Access Control

Process Isolation

Secret Management

AWS Secrets Manager

Azure Key Vault

Google Cloud Secrets

Bitwarden

Security Features

Authentication

Network Security

Runtime Security

Monitoring & Logging

Metrics Collection

Available Metrics

Structured Logging

Log Aggregation

Alert Configuration

Troubleshooting & Debugging

Diagnostic Commands

Common Issues

Service Won't Start

High Memory Usage

Slow Performance

Debug Mode Configuration

Info Level

Warning Level

Error Level

Debugging Tools

gops

panicparse

zap

delve