activejob-temporal 0.1.0

data/api/job_payload_schema.json

@@ -0,0 +1,318 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "ActiveJob Temporal Payload",
+  "type": "object",
+  "definitions": {
+    "rate_limit": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["limit", "interval", "key"],
+      "properties": {
+        "limit": { "type": "integer", "minimum": 1 },
+        "interval": { "type": "number", "exclusiveMinimum": 0 },
+        "key": { "type": "string", "minLength": 1 }
+      }
+    },
+    "rate_limits": {
+      "type": "array",
+      "items": { "$ref": "#/definitions/rate_limit" }
+    },
+    "active_job_payload": {
+      "type": "object",
+      "required": ["job_class", "job_id", "queue_name", "arguments"],
+      "additionalProperties": true,
+      "properties": {
+        "job_class": { "type": "string", "minLength": 1 },
+        "job_id": { "type": "string", "minLength": 1 },
+        "provider_job_id": { "type": ["string", "null"] },
+        "queue_name": { "type": "string", "minLength": 1 },
+        "priority": { "type": ["integer", "null"] },
+        "arguments": { "type": "array" },
+        "executions": { "type": "integer", "minimum": 0 },
+        "exception_executions": {
+          "type": "object",
+          "additionalProperties": { "type": "integer", "minimum": 0 }
+        },
+        "locale": { "type": "string" },
+        "timezone": { "type": ["string", "null"] },
+        "enqueued_at": { "type": "string", "format": "date-time" },
+        "scheduled_at": { "type": ["string", "null"], "format": "date-time" }
+      }
+    },
+    "workflow_interactions": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["job_class", "signals", "queries", "updates"],
+      "properties": {
+        "job_class": { "type": "string", "minLength": 1 },
+        "signals": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 },
+          "uniqueItems": true
+        },
+        "queries": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 },
+          "uniqueItems": true
+        },
+        "updates": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 },
+          "uniqueItems": true
+        }
+      }
+    },
+    "workflow_identity": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["workflow_name"],
+      "properties": {
+        "workflow_name": { "type": "string", "minLength": 1 },
+        "workflow_id_prefix": { "type": "string", "minLength": 1 }
+      }
+    },
+    "external_temporal_options": {
+      "type": "object",
+      "required": ["task_queue"],
+      "properties": {
+        "task_queue": { "type": "string", "minLength": 1 }
+      }
+    },
+    "active_job_chain_step": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["job_class", "job_id", "queue_name", "arguments"],
+      "properties": {
+        "job_class": { "type": "string", "minLength": 1 },
+        "job_id": { "type": "string", "minLength": 1 },
+        "queue_name": { "type": "string", "minLength": 1 },
+        "arguments": { "type": "array" },
+        "active_job": { "$ref": "#/definitions/active_job_payload" },
+        "executions": { "type": "integer", "minimum": 0 },
+        "exception_executions": {
+          "type": "object",
+          "additionalProperties": { "type": "integer", "minimum": 0 }
+        },
+        "default_activity_options": { "type": "object" },
+        "retry_policy": { "type": "object" },
+        "temporal_options": { "type": "object" },
+        "dead_letter": { "type": "object" },
+        "workflow_identity": { "$ref": "#/definitions/workflow_identity" },
+        "rate_limits": { "$ref": "#/definitions/rate_limits" },
+        "workflow_interactions": { "$ref": "#/definitions/workflow_interactions" },
+        "activity_task_queue": { "type": "string", "minLength": 1 }
+      }
+    },
+    "external_chain_step": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["temporal_operation", "temporal_type", "options"],
+      "properties": {
+        "temporal_operation": { "type": "string", "enum": ["activity", "workflow"] },
+        "temporal_type": { "type": "string", "minLength": 1 },
+        "options": { "$ref": "#/definitions/external_temporal_options" }
+      }
+    },
+    "chain_step": {
+      "anyOf": [
+        { "$ref": "#/definitions/active_job_chain_step" },
+        { "$ref": "#/definitions/external_chain_step" }
+      ]
+    },
+    "chain": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/definitions/chain_step" }
+    },
+    "child_workflow_search_attributes": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["job_class", "job_id", "queue_name", "enqueued_at"],
+      "properties": {
+        "job_class": { "type": "string", "minLength": 1 },
+        "job_id": { "type": "string", "minLength": 1 },
+        "queue_name": { "type": "string", "minLength": 1 },
+        "enqueued_at": { "type": "string", "format": "date-time" },
+        "tags": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 },
+          "uniqueItems": true
+        }
+      }
+    },
+    "active_job_child_workflow": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["job_class", "job_id", "workflow_id", "queue_name", "arguments"],
+      "properties": {
+        "job_class": { "type": "string", "minLength": 1 },
+        "job_id": { "type": "string", "minLength": 1 },
+        "workflow_id": { "type": "string", "minLength": 1 },
+        "queue_name": { "type": "string", "minLength": 1 },
+        "arguments": { "type": "array" },
+        "active_job": { "$ref": "#/definitions/active_job_payload" },
+        "executions": { "type": "integer", "minimum": 0 },
+        "exception_executions": {
+          "type": "object",
+          "additionalProperties": { "type": "integer", "minimum": 0 }
+        },
+        "default_activity_options": { "type": "object" },
+        "retry_policy": { "type": "object" },
+        "temporal_options": { "type": "object" },
+        "dead_letter": { "type": "object" },
+        "workflow_identity": { "$ref": "#/definitions/workflow_identity" },
+        "rate_limits": { "$ref": "#/definitions/rate_limits" },
+        "workflow_interactions": { "$ref": "#/definitions/workflow_interactions" },
+        "activity_task_queue": { "type": "string", "minLength": 1 },
+        "workflow_task_queue": { "type": "string", "minLength": 1 },
+        "search_attributes": { "$ref": "#/definitions/child_workflow_search_attributes" }
+      }
+    },
+    "external_child_workflow": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["temporal_operation", "temporal_type", "options"],
+      "properties": {
+        "temporal_operation": { "type": "string", "enum": ["workflow"] },
+        "temporal_type": { "type": "string", "minLength": 1 },
+        "options": { "$ref": "#/definitions/external_temporal_options" }
+      }
+    },
+    "child_workflow": {
+      "anyOf": [
+        { "$ref": "#/definitions/active_job_child_workflow" },
+        { "$ref": "#/definitions/external_child_workflow" }
+      ]
+    },
+    "child_workflows": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/definitions/child_workflow" }
+    },
+    "dependency": {
+      "type": "object",
+      "additionalProperties": false,
+      "anyOf": [
+        { "required": ["job_id"] },
+        { "required": ["workflow_id"] }
+      ],
+      "properties": {
+        "job_class": { "type": "string", "minLength": 1 },
+        "job_id": { "type": "string", "minLength": 1 },
+        "workflow_id": { "type": "string", "minLength": 1 }
+      }
+    },
+    "dependencies": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/definitions/dependency" }
+    }
+  },
+  "oneOf": [
+    {
+      "additionalProperties": false,
+      "required": ["job_class", "job_id", "queue_name", "arguments"],
+      "properties": {
+        "job_class": { "type": "string" },
+        "job_id": { "type": "string" },
+        "queue_name": { "type": "string" },
+        "arguments": { "type": "array" },
+        "active_job": { "$ref": "#/definitions/active_job_payload" },
+        "executions": { "type": "integer", "minimum": 0 },
+        "exception_executions": {
+          "type": "object",
+          "additionalProperties": { "type": "integer", "minimum": 0 }
+        },
+        "scheduled_at": { "type": "string", "format": "date-time" },
+        "default_activity_options": { "type": "object" },
+        "retry_policy": { "type": "object" },
+        "temporal_options": { "type": "object" },
+        "dead_letter": { "type": "object" },
+        "workflow_identity": { "$ref": "#/definitions/workflow_identity" },
+        "rate_limits": { "$ref": "#/definitions/rate_limits" },
+        "workflow_interactions": { "$ref": "#/definitions/workflow_interactions" },
+        "child_workflows": { "$ref": "#/definitions/child_workflows" },
+        "chain": { "$ref": "#/definitions/chain" },
+        "dependencies": { "$ref": "#/definitions/dependencies" },
+        "dependency_failure_policy": { "type": "string", "enum": ["fail", "ignore"] },
+        "activity_task_queue": { "type": "string", "minLength": 1 }
+      }
+    },
+    {
+      "additionalProperties": false,
+      "required": ["serialized_payload", "payload_serializer", "payload_serializer_version", "serialized_data"],
+      "properties": {
+        "serialized_payload": { "const": true },
+        "payload_serializer": { "type": "string", "enum": ["message_pack", "marshal"] },
+        "payload_serializer_version": { "type": "integer", "enum": [1] },
+        "serialized_data": { "type": "string" },
+        "scheduled_at": { "type": "string", "format": "date-time" },
+        "default_activity_options": { "type": "object" },
+        "retry_policy": { "type": "object" },
+        "temporal_options": { "type": "object" },
+        "dead_letter": { "type": "object" },
+        "workflow_identity": { "$ref": "#/definitions/workflow_identity" },
+        "rate_limits": { "$ref": "#/definitions/rate_limits" },
+        "workflow_interactions": { "$ref": "#/definitions/workflow_interactions" },
+        "child_workflows": { "$ref": "#/definitions/child_workflows" },
+        "chain": { "$ref": "#/definitions/chain" },
+        "dependencies": { "$ref": "#/definitions/dependencies" },
+        "dependency_failure_policy": { "type": "string", "enum": ["fail", "ignore"] },
+        "activity_task_queue": { "type": "string", "minLength": 1 }
+      }
+    },
+    {
+      "additionalProperties": false,
+      "required": ["encrypted_payload", "encrypted_payload_version", "encrypted_data"],
+      "properties": {
+        "encrypted_payload": { "const": true },
+        "encrypted_payload_version": { "type": "integer", "enum": [1, 2] },
+        "encrypted_key_id": { "type": "string", "minLength": 1 },
+        "payload_serializer": { "type": "string", "enum": ["message_pack", "marshal"] },
+        "payload_serializer_version": { "type": "integer", "enum": [1] },
+        "encrypted_data": { "type": "string" },
+        "encrypted_iv": { "type": "string" },
+        "encrypted_auth_tag": { "type": "string" },
+        "scheduled_at": { "type": "string", "format": "date-time" },
+        "default_activity_options": { "type": "object" },
+        "retry_policy": { "type": "object" },
+        "temporal_options": { "type": "object" },
+        "dead_letter": { "type": "object" },
+        "workflow_identity": { "$ref": "#/definitions/workflow_identity" },
+        "rate_limits": { "$ref": "#/definitions/rate_limits" },
+        "workflow_interactions": { "$ref": "#/definitions/workflow_interactions" },
+        "child_workflows": { "$ref": "#/definitions/child_workflows" },
+        "chain": { "$ref": "#/definitions/chain" },
+        "dependencies": { "$ref": "#/definitions/dependencies" },
+        "dependency_failure_policy": { "type": "string", "enum": ["fail", "ignore"] },
+        "activity_task_queue": { "type": "string", "minLength": 1 }
+      },
+      "dependencies": {
+        "payload_serializer": ["payload_serializer_version"],
+        "payload_serializer_version": ["payload_serializer"]
+      }
+    },
+    {
+      "additionalProperties": false,
+      "required": ["external_payload", "external_payload_version", "external_payload_reference"],
+      "properties": {
+        "external_payload": { "const": true },
+        "external_payload_version": { "type": "integer", "enum": [1] },
+        "external_payload_reference": {},
+        "scheduled_at": { "type": "string", "format": "date-time" },
+        "default_activity_options": { "type": "object" },
+        "retry_policy": { "type": "object" },
+        "temporal_options": { "type": "object" },
+        "dead_letter": { "type": "object" },
+        "workflow_identity": { "$ref": "#/definitions/workflow_identity" },
+        "rate_limits": { "$ref": "#/definitions/rate_limits" },
+        "workflow_interactions": { "$ref": "#/definitions/workflow_interactions" },
+        "child_workflows": { "$ref": "#/definitions/child_workflows" },
+        "chain": { "$ref": "#/definitions/chain" },
+        "dependencies": { "$ref": "#/definitions/dependencies" },
+        "dependency_failure_policy": { "type": "string", "enum": ["fail", "ignore"] },
+        "activity_task_queue": { "type": "string", "minLength": 1 }
+      }
+    }
+  ]
+}

data/bin/temporal-worker

@@ -0,0 +1,295 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/activejob/temporal"
+require "optparse"
+
+begin
+  require "temporalio/worker"
+rescue LoadError => e
+  warn("temporalio-worker gem is required to run this worker: #{e.message}")
+  exit(1)
+end
+
+metrics_public_bind_env = ENV.fetch("ACTIVEJOB_TEMPORAL_METRICS_ALLOW_PUBLIC_BIND", nil)
+metrics_allow_public_bind = unless metrics_public_bind_env.nil?
+                              ActiveJob::Temporal::BindPolicy.allow_public_bind?(metrics_public_bind_env)
+                            end
+
+options = {
+  health_check_bind: ENV.fetch(
+    "ACTIVEJOB_TEMPORAL_HEALTH_CHECK_BIND",
+    ActiveJob::Temporal::HealthCheckServer::DEFAULT_BIND_ADDRESS
+  ),
+  health_check_allow_public_bind: ActiveJob::Temporal::BindPolicy.allow_public_bind?(
+    ENV.fetch("ACTIVEJOB_TEMPORAL_HEALTH_CHECK_ALLOW_PUBLIC_BIND", nil)
+  ),
+  health_check_port: ENV.fetch("ACTIVEJOB_TEMPORAL_HEALTH_CHECK_PORT", nil),
+  metrics_bind: ENV.fetch("ACTIVEJOB_TEMPORAL_METRICS_BIND", nil),
+  metrics_allow_public_bind: metrics_allow_public_bind,
+  metrics_port: ENV.fetch("ACTIVEJOB_TEMPORAL_METRICS_PORT", nil),
+  pool_size: ENV.fetch("ACTIVEJOB_TEMPORAL_WORKER_POOL_SIZE", 1)
+}
+
+OptionParser.new do |parser|
+  parser.banner = "Usage: temporal-worker [options]"
+
+  parser.on("--health-check-port PORT", Integer, "Expose GET /health on PORT") do |port|
+    options[:health_check_port] = port
+  end
+
+  parser.on("--health-check-bind HOST", "Bind health endpoint to HOST") do |host|
+    options[:health_check_bind] = host
+  end
+
+  parser.on(
+    "--allow-public-health-check-bind",
+    "Allow health endpoint to bind non-loopback addresses"
+  ) do
+    options[:health_check_allow_public_bind] = true
+  end
+
+  parser.on("--metrics-port PORT", Integer, "Expose GET /metrics on PORT") do |port|
+    options[:metrics_port] = port
+  end
+
+  parser.on("--metrics-bind HOST", "Bind metrics endpoint to HOST") do |host|
+    options[:metrics_bind] = host
+  end
+
+  parser.on("--allow-public-metrics-bind", "Allow metrics endpoint to bind non-loopback addresses") do
+    options[:metrics_allow_public_bind] = true
+  end
+
+  parser.on("--pool-size SIZE", Integer, "Run SIZE worker processes under a supervising pool") do |size|
+    options[:pool_size] = size
+  end
+end.parse!(ARGV)
+
+begin
+  ActiveJob::Temporal::RailsEnvironmentLoader.load!(rails_root: ENV.fetch("RAILS_ROOT", "."))
+rescue ActiveJob::Temporal::RailsEnvironmentLoader::Error => e
+  warn "Error: #{e.message}"
+  exit(1)
+end
+
+# Read from configuration singleton (already set by Rails initializer)
+config = ActiveJob::Temporal.config
+task_queue = config.task_queue
+max_concurrent_activities = config.max_concurrent_activities
+max_concurrent_workflows = config.max_concurrent_workflow_tasks
+prometheus_adapter = config.observability.adapter(:prometheus)
+metrics_port = options[:metrics_port] || prometheus_adapter&.metrics_server&.port
+if metrics_port && !prometheus_adapter
+  warn(
+    "Error: Prometheus metrics require the Prometheus observability adapter. " \
+    "Add `require \"activejob/temporal/observability/prometheus\"` and enable " \
+    "`config.observability.use :prometheus`."
+  )
+  exit(1)
+end
+metrics_bind = options[:metrics_bind] || prometheus_adapter&.metrics_server&.bind ||
+               ActiveJob::Temporal::MetricsServer::DEFAULT_BIND_ADDRESS
+metrics_allow_public_bind = if options[:metrics_allow_public_bind].nil?
+                              prometheus_adapter&.metrics_server&.allow_public_bind || false
+                            else
+                              options[:metrics_allow_public_bind]
+                            end
+begin
+  pool_size = Integer(options[:pool_size])
+rescue ArgumentError, TypeError
+  warn "Error: --pool-size must be a positive integer"
+  exit(1)
+end
+
+if pool_size < 1
+  warn "Error: --pool-size must be a positive integer"
+  exit(1)
+end
+
+reload_signal = config.tls_reload_signal.to_s.sub(/\ASIG/i, "").upcase
+unless Signal.list.key?(reload_signal) && !ActiveJob::Temporal::UNTRAPPABLE_SIGNALS.include?(reload_signal)
+  warn(
+    "Error: ACTIVEJOB_TEMPORAL_TLS_RELOAD_SIGNAL must be a signal name safe to trap, " \
+    "got: #{config.tls_reload_signal.inspect}"
+  )
+  exit(1)
+end
+
+public_bind_errors = []
+if options[:health_check_port] &&
+   ActiveJob::Temporal::BindPolicy.public_bind?(options[:health_check_bind]) &&
+   !options[:health_check_allow_public_bind]
+  public_bind_errors << [
+    "health check",
+    options[:health_check_bind],
+    "--allow-public-health-check-bind",
+    "ACTIVEJOB_TEMPORAL_HEALTH_CHECK_ALLOW_PUBLIC_BIND=true"
+  ]
+end
+if metrics_port &&
+   ActiveJob::Temporal::BindPolicy.public_bind?(metrics_bind) &&
+   !metrics_allow_public_bind
+  public_bind_errors << [
+    "metrics",
+    metrics_bind,
+    "--allow-public-metrics-bind",
+    "ACTIVEJOB_TEMPORAL_METRICS_ALLOW_PUBLIC_BIND=true"
+  ]
+end
+
+unless public_bind_errors.empty?
+  public_bind_errors.each do |endpoint, bind_address, flag, env_var|
+    warn(
+      "Error: refusing to expose unauthenticated #{endpoint} endpoint on non-loopback address " \
+      "#{bind_address.inspect} without explicit public bind opt-in"
+    )
+    warn "Pass #{flag} or set #{env_var} only when the endpoint is protected from untrusted networks."
+  end
+  exit(1)
+end
+
+if pool_size > 1
+  pool = ActiveJob::Temporal::WorkerPool.new(
+    size: pool_size,
+    health_check_port: options[:health_check_port],
+    health_check_bind: options[:health_check_bind],
+    health_check_allow_public_bind: options[:health_check_allow_public_bind],
+    metrics_port: metrics_port,
+    metrics_bind: metrics_bind,
+    metrics_allow_public_bind: metrics_allow_public_bind,
+    max_concurrent_activities: max_concurrent_activities,
+    max_concurrent_workflows: max_concurrent_workflows
+  )
+
+  ActiveJob::Temporal::Logger.log_event(
+    "worker_pool_started",
+    size: pool_size,
+    task_queue: task_queue,
+    health_check_port: options[:health_check_port],
+    metrics_port: metrics_port
+  )
+
+  pool.start.wait
+  exit
+end
+
+client = ActiveJob::Temporal.client
+worker_health = ActiveJob::Temporal::WorkerHealth.new(
+  task_queue: task_queue,
+  namespace: ActiveJob::Temporal.config.namespace,
+  target: ActiveJob::Temporal.config.target,
+  max_concurrent_activities: max_concurrent_activities,
+  max_concurrent_workflows: max_concurrent_workflows
+)
+
+worker = Temporalio::Worker.new(
+  client: client,
+  task_queue: task_queue,
+  workflows: [
+    ActiveJob::Temporal::Workflows::AjWorkflow,
+    ActiveJob::Temporal::Workflows::DeadLetterWorkflow
+  ],
+  activities: [
+    ActiveJob::Temporal::Activities::RateLimitActivity,
+    ActiveJob::Temporal::Activities::DependencyStatusActivity,
+    ActiveJob::Temporal::Activities::AjRunnerActivity
+  ],
+  tuner: Temporalio::Worker::Tuner.create_fixed(
+    workflow_slots: max_concurrent_workflows,
+    activity_slots: max_concurrent_activities,
+    local_activity_slots: max_concurrent_activities
+  ),
+  interceptors: [worker_health]
+)
+
+ActiveJob::Temporal::Logger.log_event(
+  "worker_started",
+  task_queue: task_queue,
+  max_concurrent_activities: max_concurrent_activities,
+  max_concurrent_workflows: max_concurrent_workflows,
+  namespace: ActiveJob::Temporal.config.namespace,
+  target: ActiveJob::Temporal.config.target
+)
+
+health_check_server = nil
+if options[:health_check_port]
+  health_check_server = ActiveJob::Temporal::HealthCheckServer.new(
+    port: options[:health_check_port],
+    bind_address: options[:health_check_bind],
+    allow_public_bind: options[:health_check_allow_public_bind],
+    state: worker_health
+  ).start
+
+  ActiveJob::Temporal::Logger.log_event(
+    "health_check_server_started",
+    bind_address: health_check_server.bind_address,
+    port: health_check_server.port
+  )
+end
+
+metrics_server = nil
+if metrics_port
+  metrics_server = prometheus_adapter.start_metrics_server(
+    port: metrics_port,
+    bind_address: metrics_bind,
+    allow_public_bind: metrics_allow_public_bind
+  )
+
+  ActiveJob::Temporal::Logger.log_event(
+    "metrics_server_started",
+    bind_address: metrics_server.bind_address,
+    port: metrics_server.port
+  )
+end
+
+client_reloader = ActiveJob::Temporal::WorkerClientReloader.new(worker: worker)
+reload_signal_queue = ActiveJob::Temporal::ReloadSignalQueue.new
+reload_signal_thread = Thread.new do
+  loop do
+    signal = reload_signal_queue.pop
+    break unless signal
+
+    begin
+      client_reloader.reload(source: "signal:#{signal}")
+    rescue StandardError
+      # Reload failures are already logged and should not stop the worker.
+    end
+  end
+end
+Signal.trap(reload_signal) { reload_signal_queue.push(reload_signal) }
+
+certificate_watcher = nil
+if config.tls_cert_watch
+  certificate_watcher = ActiveJob::Temporal::CertificateWatcher.new(
+    paths: ActiveJob::Temporal::CertificateWatcher.paths_from_config(config),
+    reload_callback: lambda {
+      begin
+        client_reloader.reload(source: "file_watch")
+      rescue StandardError
+        # Reload failures are already logged and should not stop the watcher.
+      end
+    }
+  ).start
+end
+
+begin
+  worker_health.mark_started!
+  Temporalio::Worker.run_all(
+    worker,
+    shutdown_signals: %w[SIGINT SIGTERM]
+  )
+rescue Interrupt
+  # Temporal worker raises Interrupt on shutdown signals; swallow to allow clean exit.
+ensure
+  worker_health.mark_stopped!
+  certificate_watcher&.stop
+  reload_signal_queue.close
+  reload_signal_thread.join(1)
+  health_check_server&.stop
+  metrics_server&.stop
+  ActiveJob::Temporal::Logger.log_event(
+    "worker_shutdown",
+    task_queue: task_queue
+  )
+end