foreman_openbolt 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f42a0b837a7513fd603eaeb6e9b5a75a31be236f6f64d7c8d142404f3d557f1
-  data.tar.gz: 605ce929b8b03b615cebf42eb343b18bdc6ae3f0169af349f8476be86a8737eb
+  metadata.gz: 3747d57bc5198327d01255ec665724e38a46dbfd91fd1e5bd764d6cf3ddd3bb3
+  data.tar.gz: ad67d388a524680a567ffdf020e35bbb364471bd190cbdfc597c25d88928a4d2
 SHA512:
-  metadata.gz: 490aa0856a8806f9237c1a1284d626290571835881776e92892921d8414f6fa8f6d18edf73a6e7328ff3d666d5d515158474db6097f0e40915a0b2855dc2eb99
-  data.tar.gz: 92be9c08b82ff27aace85e78005bdf73c905c1d0b2ff2583eda208f535c03c69fa0a3736d48c8e940cedd3eb929a8325a93218efe6873618c777820a0ba84025
+  metadata.gz: 1570a5623355cd514276d9e25aece89f2b3f5970bde5efa80db4f9cbe1c4e59eb030b4b5194906d9e9b93f6ec62ac3059e9ed1671cfd612b025d805e3cff7f8e
+  data.tar.gz: b335d7b62ff7c6a6d93e39d2ae12c8357ca32b36299313ecc28a23ecc9190d74016a60f03e61f8bacbbf2ba7583cfb15b96b31acf5c21590d59dafc70934fb84

data/README.md

@@ -10,8 +10,8 @@ Bringing OpenBolt Task & Plans into Foreman!
 
 ## Introduction
 
-[OpenBolt](https://github.com/OpenVoxProject/openbolt) is the open source successor of [bolt](https://github.com/puppetlabs/bolt) by [Perforce](https://www.perforce.com/).
-OpenBolt supports running Tasks or Plans against various targets / via different transport protocols.
+[OpenBolt](https://github.com/OpenVoxProject/openbolt) is the open source successor of [Bolt](https://github.com/puppetlabs/bolt) by [Perforce](https://www.perforce.com/).
+OpenBolt supports running Tasks or Plans against various targets  via different transport protocols.
 OpenBolt and Bolt are CLI-only tools.
 They connect to the targets from a central location (usually a jumpnode or workstation).
 
@@ -45,21 +45,17 @@ See [How_to_Install_a_Plugin](https://theforeman.org/plugins/#2.Installation) fo
 The [theforeman/foreman](https://github.com/theforeman/puppet-foreman/blob/master/manifests/plugin/openbolt.pp) puppet module also supports the **Foreman plugin** installation.
 The [theforeman/foreman_proxy](https://github.com/theforeman/puppet-foreman_proxy/blob/master/manifests/plugin/openbolt.pp) puppet module also supports the **Foreman Smartproxy plugin** installation.
 
-**as of 2025-12-15 integration into the foreman installer is still pending**
 
 The Foreman plugin provides UI elements to start Tasks on various nodes.
 Foreman then talks to a Smartproxy to run OpenBolt.
 The Smartproxy also establishes the connections to the various targets.
-This is usually a ssh or WinRM connection (and soon choria, see [the TODO section](#todo).
+This is usually a ssh or WinRM connection (and soon choria, see [the TODO section](#todo)).
 
 You need to have `bolt` in your `$PATH` on the Smartproxy.
-You can use the legacy bolt packages from Perforce from the `puppet-tools` repo on [apt.puppet.com](https://apt.puppet.com/) or [yum.puppet.com](https://yum.puppet.com/).
-If you have an active Perforce license, you can also download [their commercial bolt version](https://help.puppet.com/bolt/current/topics/bolt_installing.htm).
 OpenBolt packages are available at [yum.voxpupuli.org](https://yum.voxpupuli.org/) & [apt.voxpupuli.org](https://apt.voxpupuli.org/) in the openvox8 repo.
+You can also use the legacy Bolt packages from Perforce from the `puppet-tools` repo on [apt.puppet.com](https://apt.puppet.com/) or [yum.puppet.com](https://yum.puppet.com/).
 
-**The Foreman integration is tested with OpenBolt and the last Bolt opensource release 4.0.0**
-
-The integration is supported on Foreman 3.15 and all following versions, including development/nightly builds.
+The integration is supported on Foreman 3.17 and all following versions, including development/nightly builds.
 
 OpenBolt relies on Tasks & Plans. They are distributed as puppet modules.
 The plugin assumes that you deployed your code.
@@ -115,11 +111,118 @@ For failed tasks but also for passed tasks.
 
 ![service task passed on two nodes](./ext/task-successful-result.png)
 
+## Development
+
+### Linting
+
+```bash
+bundle exec rake lint        # Run all linters (rubocop, erb_lint, eslint)
+bundle exec rake lint:fix    # Auto-fix where possible
+```
+
+Ruby and ERB linters run directly. The JavaScript linter requires npm dependencies, so either install them locally (`npm install --legacy-peer-deps`) or run lint:js inside a container:
+
+```bash
+CONTAINER=1 bundle exec rake lint:js
+```
+
+### Unit Tests
+
+Unit tests run inside Docker containers with a full Foreman installation. Requires Docker with compose support.
+
+```bash
+bundle exec rake test:unit:up    # Build image, start containers, install deps
+bundle exec rake test:unit:ruby  # Run Ruby tests
+bundle exec rake test:unit:js    # Run JavaScript tests
+bundle exec rake test:unit:all   # Run all unit tests
+bundle exec rake test:unit:down  # Stop and remove containers
+bundle exec rake test              # Shortcut: up, test, down in one step
+```
+
+Set `FOREMAN_VERSION` to test against a specific Foreman version (default: `3.18`):
+
+```bash
+FOREMAN_VERSION=3.17 bundle exec rake test:unit:up
+```
+
+### Acceptance Tests
+
+Acceptance tests exercise the plugin through the browser using Capybara and Selenium. They build RPMs, start a multi-container environment (Foreman + OpenVox + SSH targets + Chromium), and run tests against the real UI.
+
+**Prerequisites:**
+
+```bash
+bundle install --with acceptance
+```
+
+The [smart_proxy_openbolt](https://github.com/overlookinfra/smart_proxy_openbolt) and [foreman-packaging](https://github.com/theforeman/foreman-packaging) repos are cloned automatically when needed.
+
+**Running:**
+
+```bash
+bundle exec rake acceptance         # Full cycle: up, run tests, down
+bundle exec rake acceptance:up      # Build RPMs, start Foreman, configure everything
+bundle exec rake acceptance:run     # Run tests (requires up first)
+bundle exec rake acceptance:down    # Stop containers
+bundle exec rake acceptance:clean   # Full reset: stop containers, remove images and artifacts
+```
+
+The `acceptance:up` task is idempotent and can be re-run to pick up new RPM changes. It caches the Foreman Docker image per version so subsequent runs are faster.
+
+**Watching tests in the browser:**
+
+Set `HEADFUL=1` to disable headless mode, then open `http://localhost:7900` (password: `secret`) to watch the tests via noVNC:
+
+```bash
+HEADFUL=1 bundle exec rake acceptance:run
+```
+
+**Running a subset of tests:**
+
+`acceptance:run` accepts `TEST=<path>` to limit which test files are loaded, and `TESTOPTS=<opts>` to forward options (e.g. `--name=/pattern/`) to the Test::Unit autorunner. Both can be combined.
+
+```bash
+# Run every test in one file
+bundle exec rake acceptance:run TEST=test/acceptance/tests/settings_test.rb
+
+# Run a single test by exact method name (any file)
+bundle exec rake acceptance:run TESTOPTS='--name=test_echo_task_succeeds_on_all_targets'
+
+# Run tests whose name matches a regex within one file
+bundle exec rake acceptance:run \
+  TEST=test/acceptance/tests/settings_test.rb \
+  TESTOPTS='--name=/host_key/'
+```
+
+**Environment variables:**
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `CHROMEDRIVER_URL` | `http://localhost:4444` | Selenium WebDriver endpoint |
+| `FOREMAN_BRANCH` | `<version>-stable` | Foreman git branch for unit test image (derived from `FOREMAN_VERSION`) |
+| `FOREMAN_PACKAGING_REPO` | `https://github.com/theforeman/foreman-packaging.git` | Git URL for foreman-packaging (cloned automatically for RPM builds) |
+| `FOREMAN_PASS` | `changeme` | Foreman login password |
+| `FOREMAN_URL` | `https://foreman` | Foreman URL as seen by Chrome. Override to run tests against a live instance |
+| `FOREMAN_USER` | `admin` | Foreman login username |
+| `FOREMAN_VERSION` | `3.18` | Foreman version to test against |
+| `HEADFUL` | unset | Set to `1` to show the browser in noVNC |
+| `SELENIUM_IMAGE` | auto-detected (ARM/x86) | Selenium container image (auto-selects `seleniarm/standalone-chromium` or `selenium/standalone-chrome`) |
+| `SMART_PROXY_OPENBOLT_REF` | `main` | Branch or tag to clone |
+| `SMART_PROXY_OPENBOLT_REPO` | `https://github.com/overlookinfra/smart_proxy_openbolt.git` | Git URL for smart_proxy_openbolt (cloned automatically for RPM builds) |
+
+### Building Packages
+
+Build RPM or DEB packages locally using containers. The [foreman-packaging](https://github.com/theforeman/foreman-packaging) repo is cloned automatically:
+
+```bash
+bundle exec rake build:rpm   # Build RPM
+bundle exec rake build:deb   # Build DEB
+```
 
 ## TODO
 
 * Integrate plans into the web UI
-* provide a choria transport plugin
+* Provide a choria transport plugin
 
 ## Contributing & support
 
@@ -145,14 +248,82 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-## how to release
+## How to Release
+
+### Version locations
+
+The version is maintained in two files:
+
+1. `lib/foreman_openbolt/version.rb` -- the gem version (authoritative source)
+2. `package.json` -- the npm package version (must match)
+
+If the minimum Foreman version changes, also update:
+
+3. `lib/foreman_openbolt/engine.rb` -- `requires_foreman '>= X.Y.Z'`
+4. `.github/workflows/build.yml` -- default `foreman_version` and `foreman_packaging_ref` inputs
+
+### Release steps
+
+1. Go to [Actions > Prepare Release](../../actions/workflows/prepare_release.yml) and run the workflow with the version to release (e.g. `1.2.0`)
+2. The workflow bumps the version in `version.rb` and `package.json`, generates the changelog, and opens a PR with the `skip-changelog` label
+3. Review and merge the PR
+4. Go to [Actions > Release](../../actions/workflows/release.yml) and run the workflow with the same version
+5. The release workflow:
+   - Verifies the version in `version.rb` matches the input
+   - Creates and pushes a git tag
+   - Builds the gem
+   - Creates a GitHub Release with auto-generated notes and the gem attached
+   - Publishes the gem to GitHub Packages
+   - Publishes the gem to RubyGems.org (requires the `release` environment)
+   - Verifies the gem is available on RubyGems.org
+
+### RPM/DEB packaging
+
+After the gem is published to RubyGems, both RPM and DEB packages need to be updated in [theforeman/foreman-packaging](https://github.com/theforeman/foreman-packaging).
+
+A bot automatically creates PRs against the `rpm/develop` and `deb/develop` branches to pick up the new gem version. These PRs build packages for Foreman nightly.
+
+For stable Foreman releases (currently 3.17 and 3.18), cherry-pick the packaging commits from the develop branches into the corresponding stable branches. For each stable version you want to support:
+
+```bash
+cd foreman-packaging
+
+# RPM: cherry-pick from rpm/develop into a branch off the stable target
+git checkout rpm/3.18
+git checkout -b cherry-pick/rubygem-foreman_openbolt-rpm-3.18
+git cherry-pick <commit-from-rpm/develop>
+# Push to your fork and open a PR targeting rpm/3.18
+
+# DEB: same approach for the deb side
+git checkout deb/3.18
+git checkout -b cherry-pick/rubygem-foreman-openbolt-deb-3.18
+git cherry-pick <commit-from-deb/develop>
+# Push to your fork and open a PR targeting deb/3.18
+```
+
+PRs against stable branches should be labeled "Stable branch".
+
+**Alternative: manual version bump**
+
+If the cherry-pick doesn't apply cleanly, you can bump the version manually on the stable branch instead.
+
+*RPM:* Checkout the target branch and run `bump_rpm.sh`:
+```bash
+cd foreman-packaging
+git checkout rpm/3.18
+git checkout -b bump_rpm/rubygem-foreman_openbolt
+./bump_rpm.sh packages/plugins/rubygem-foreman_openbolt
+# Review changes, push to your fork, and open a PR targeting rpm/3.18
+```
 
-* bump version in `lib/foreman_openbolt/version.rb` and `package.json`
-* run `CHANGELOG_GITHUB_TOKEN=github_pat... bundle exec rake changelog`
-* create a PR
-* get a review & merge
-* create and push a tag
-* github actions will publish the tag
+*DEB:* Checkout the target branch and update these files:
+- `debian/gem.list` -- new gem filename
+- `foreman_openbolt.rb` -- new version
+- `debian/control` -- dependency versions (if changed)
+- `debian/changelog` -- add a new entry
 
-The Foreman team packages this gem as Debian package (deb) and as RedHat package (rpm).
-They have a bot that will automatically propose an rpm/deb update at [github.com/theforeman/foreman-packaging](https://github.com/theforeman/foreman-packaging/pulls).
+```bash
+git checkout deb/3.18
+git checkout -b bump_deb/ruby-foreman-openbolt
+# Make the changes above, push to your fork, and open a PR targeting deb/3.18
+```

data/Rakefile

@@ -1,99 +1,23 @@
 # frozen_string_literal: true
 
-# !/usr/bin/env rake
-
-begin
-  require 'rdoc/task'
-rescue LoadError
-  require 'rdoc/rdoc'
-  require 'rake/rdoctask'
-  RDoc::Task = Rake::RDocTask
-end
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'ForemanOpenbolt'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
-
-begin
-  require 'rubocop/rake_task'
-  RuboCop::RakeTask.new
-rescue LoadError
-  puts 'Rubocop not loaded.'
-end
-
-# This is all kinda screwy. Fix it up later.
-LINTERS = {
-  ruby: { cmd: 'rubocop', fix: '--auto-correct' },
-  erb: { cmd: 'erb_lint', fix: '--autocorrect', glob: '**/*.erb' },
-  js: { image: 'registry.access.redhat.com/ubi9/nodejs-20:latest', cmd: 'npm run lint --', fix: '--fix' },
-}.freeze
-
-namespace :lint do
-  def fix?
-    !ENV['FIX'].nil?
-  end
-
-  def local?
-    !ENV['LOCAL'].nil?
-  end
-
-  def bin
-    ENV['CONTAINER_BIN'] || 'docker'
-  end
-
-  LINTERS.each do |name, cfg|
-    desc "Run #{name} linter#{' (fix)' if fix?}"
-    task name do
-      cmd = [cfg[:cmd]]
-      cmd << cfg[:fix] if fix?
-      cmd << cfg[:glob] unless cfg[:glob].nil? || cfg[:glob].empty? # rubocop:disable Rails/Blank
-      cmd = cmd.join(' ')
-      if cfg[:image] && !local?
-        cmd = "#{bin} run --rm -v #{Dir.pwd}:/code #{cfg[:image]} /bin/bash -c " +
-              "'cd /code && npm install --loglevel=error && #{cmd}'"
-      end
-      sh cmd
-    end
-  end
-
-  desc 'Run all linters'
-  task all: LINTERS.keys
-
-  desc 'Run all linters and apply fixes'
-  task :fix do
-    ENV['FIX'] = 'true'
-    Rake::Task['lint:all'].invoke
+require_relative 'rakelib/utils/shell'
+
+def latest_foreman_version
+  result = Shell.capture(
+    ['git', 'ls-remote', '--tags', 'https://github.com/theforeman/foreman.git'],
+    print_command: false, allowed_exit_codes: [0, 1]
+  )
+  tags = result.output.scan(%r{refs/tags/([^\s]+)$}).flatten
+  versions = tags.filter_map do |tag|
+    Gem::Version.new(tag)
+  rescue ArgumentError
+    nil
   end
+  latest = versions.reject(&:prerelease?).max
+  latest ? "#{latest.segments[0]}.#{latest.segments[1]}" : '3.18'
 end
 
-task default: ['lint:all', 'test']
-
-begin
-  require 'rubygems'
-  require 'github_changelog_generator/task'
+DEFAULT_FOREMAN_VERSION = latest_foreman_version
+FOREMAN_VERSION = ENV.fetch('FOREMAN_VERSION', DEFAULT_FOREMAN_VERSION)
 
-  GitHubChangelogGenerator::RakeTask.new :changelog do |config|
-    config.exclude_labels = %w[duplicate question invalid wontfix wont-fix skip-changelog github_actions]
-    config.user = 'overlookinfra'
-    config.project = 'foreman_openbolt'
-    gem_version = Gem::Specification.load("#{config.project}.gemspec").version
-    config.future_release = gem_version
-  end
-rescue LoadError
-  task :changelog do
-    abort("Run `bundle install --with release` to install the `github_changelog_generator` gem.")
-  end
-end
+task default: :lint

data/app/controllers/foreman_openbolt/task_controller.rb

@@ -13,10 +13,10 @@ module ForemanOpenbolt
     REDACTED_PLACEHOLDER = '*****'
 
     before_action :load_smart_proxy, only: [
-      :fetch_tasks, :reload_tasks, :fetch_openbolt_options, :launch_task, :job_status, :job_result
+      :fetch_tasks, :reload_tasks, :fetch_openbolt_options, :launch_task
     ]
     before_action :load_openbolt_api, only: [
-      :fetch_tasks, :reload_tasks, :fetch_openbolt_options, :launch_task, :job_status, :job_result
+      :fetch_tasks, :reload_tasks, :fetch_openbolt_options, :launch_task
     ]
     before_action :load_task_job, only: [:job_status, :job_result]
 
@@ -44,11 +44,18 @@ module ForemanOpenbolt
     def fetch_openbolt_options
       options = @openbolt_api.openbolt_options
 
-      # Get defaults from Foreman settings
+      # Get defaults from Foreman settings.
+      # For encrypted settings, show the placeholder only if a non-empty value
+      # has been saved, so the UI shows an empty field for unconfigured passwords
+      # instead of a misleading placeholder.
       defaults = {}
       openbolt_settings.each do |setting|
         key = setting.name.sub(/^openbolt_/, '')
-        defaults[key] = setting.encrypted? ? ENCRYPTED_PLACEHOLDER : setting.value if setting.value.present?
+        if setting.encrypted?
+          defaults[key] = ENCRYPTED_PLACEHOLDER unless setting.value.to_s.empty?
+        else
+          defaults[key] = setting.value
+        end
       end
 
       # Merge the defaults into the options metadata
@@ -60,10 +67,10 @@ module ForemanOpenbolt
 
       render json: result
     rescue ProxyAPI::ProxyException => e
-      logger.error("OpenBolt API error for fetch_openbolt_options: #{e.message}")
+      log_exception('fetch_openbolt_options', e)
       render_error("Smart Proxy error: #{e.message}", :bad_gateway)
     rescue StandardError => e
-      logger.error("Unexpected error in fetch_openbolt_options: #{e.class}: #{e.message}")
+      log_exception('fetch_openbolt_options', e)
       render_error("Internal server error: #{e.message}", :internal_server_error)
     end
 
@@ -94,9 +101,12 @@ module ForemanOpenbolt
           options: options
         )
 
-        logger.info("Task execution response: #{response.inspect}")
+        logger.debug("Task execution response: #{response.inspect}")
 
-        return render_error("Task execution failed: #{response['error']}", :bad_request) if response['error']
+        if response['error']
+          error_detail = response['error'].is_a?(Hash) ? response['error']['message'] : response['error']
+          return render_error("Task execution failed: #{error_detail}", :bad_request)
+        end
         return render_error('Task execution failed: No job ID returned', :bad_request) unless response['id']
 
         metadata = @openbolt_api.tasks[task_name] || {}
@@ -117,15 +127,17 @@ module ForemanOpenbolt
 
         render json: {
           job_id: response['id'],
-          proxy_id: @smart_proxy.id,
-          proxy_name: @smart_proxy.name,
         }
+      rescue ArgumentError => e
+        # From merge_encrypted_defaults when a user submits the encrypted
+        # placeholder for an option that has no saved Foreman setting.
+        log_exception('launch_task', e)
+        render_error(e.message, :bad_request)
       rescue ActiveRecord::RecordInvalid => e
-        logger.error("Failed to create TaskJob: #{e.message}")
+        log_exception('launch_task', e)
         render_error("Database error: #{e.message}", :internal_server_error)
       rescue StandardError => e
-        logger.error("Task launch error: #{e.class}: #{e.message}")
-        logger.error("Backtrace: #{e.backtrace.first(5).join("\n")}")
+        log_exception('launch_task', e)
         render_error("Error launching task: #{e.message}", :internal_server_error)
       end
     end
@@ -142,6 +154,10 @@ module ForemanOpenbolt
         task_description: @task_job.task_description,
         task_parameters: @task_job.task_parameters,
         targets: @task_job.targets,
+        smart_proxy: {
+          id: @task_job.smart_proxy_id,
+          name: @task_job.smart_proxy&.name || '(unknown)',
+        },
       }
     end
 
@@ -158,10 +174,10 @@ module ForemanOpenbolt
 
     # List of all task history
     def fetch_task_history
+      per_page = [(params[:per_page] || 20).to_i, 100].min
       @task_history = TaskJob.includes(:smart_proxy)
                              .recent
-                             .paginate(page: params[:page],
-                               per_page: (params[:per_page] || 20).to_i)
+                             .paginate(page: params[:page], per_page: per_page)
 
       render json: {
         results: @task_history.map { |job| serialize_task_job(job) },
@@ -169,18 +185,11 @@ module ForemanOpenbolt
         page: @task_history.current_page,
         per_page: @task_history.per_page,
       }
+    rescue StandardError => e
+      log_exception('fetch_task_history', e)
+      render_error("Error loading task history: #{e.message}", :internal_server_error)
     end
 
-    # Show a specific task job
-    def show
-      task_job = TaskJob.find(params[:id])
-      render json: serialize_task_job(task_job, detailed: true)
-    rescue ActiveRecord::RecordNotFound
-      render_error('Task job not found', :not_found)
-    end
-
-    private
-
     def load_smart_proxy
       proxy_id = params[:proxy_id]
       if proxy_id.blank?
@@ -207,7 +216,7 @@ module ForemanOpenbolt
       begin
         @openbolt_api = ProxyAPI::Openbolt.new(url: @smart_proxy.url)
       rescue StandardError => e
-        logger.error("Failed to initialize OpenBolt API for proxy #{@smart_proxy.name}: #{e.message}")
+        log_exception("load_openbolt_api for proxy #{@smart_proxy.name}", e)
         render_error("Failed to connect to Smart Proxy", :bad_gateway)
         return false
       end
@@ -218,14 +227,17 @@ module ForemanOpenbolt
     def load_task_job
       job_id = params[:job_id]
       logger.debug("load_task_job - Job ID: #{job_id}")
-      return if job_id.blank?
+      if job_id.blank?
+        render_error('Job ID is required', :bad_request)
+        return false
+      end
 
       @task_job = TaskJob.find_by(job_id: job_id)
       logger.debug("load_task_job - Task Job: #{@task_job.inspect}")
     end
 
     def openbolt_settings
-      @openbolt_settings ||= Setting.where("name LIKE 'openbolt_%'")
+      @openbolt_settings ||= Foreman.settings.select { |s| s.name.start_with?('openbolt_') }
     end
 
     def encrypted_settings
@@ -233,13 +245,18 @@ module ForemanOpenbolt
     end
 
     def merge_encrypted_defaults(options)
-      encrypted = options.select { |_, v| v == ENCRYPTED_PLACEHOLDER }
-      encrypted.each do |key, _|
-        setting = Setting.find_by(name: "openbolt_#{key}")
-        raise "Could not find setting called openbolt_#{key}" if setting.nil?
-        options[key] = setting.value
+      merged = options.dup
+      merged.each do |key, value|
+        next unless value == ENCRYPTED_PLACEHOLDER
+
+        saved = Setting["openbolt_#{key}"]
+        if saved.nil? || saved.to_s.empty?
+          raise ArgumentError,
+            "No saved value for encrypted option '#{key}'. Configure it in Administer > Settings or provide a value."
+        end
+        merged[key] = saved
       end
-      options
+      merged
     end
 
     def scrub_options_for_storage(options)
@@ -256,19 +273,24 @@ module ForemanOpenbolt
       logger.debug("OpenBolt API call #{method_name} successful for proxy #{@smart_proxy.name}")
       render json: result
     rescue ProxyAPI::ProxyException => e
-      logger.error("OpenBolt API error for #{method_name}: #{e.message}")
+      log_exception(method_name, e)
       render_error("Smart Proxy error: #{e.message}", :bad_gateway)
     rescue StandardError => e
-      logger.error("Unexpected error in #{method_name}: #{e.class}: #{e.message}")
+      log_exception(method_name, e)
       render_error("Internal server error: #{e.message}", :internal_server_error)
     end
 
+    def log_exception(message, exception)
+      logger.error("#{message}: #{exception.class}: #{exception.message}")
+      logger.error(exception.backtrace.join("\n")) if exception.backtrace
+    end
+
     def render_error(message, status)
       render json: { error: message }, status: status
     end
 
-    def serialize_task_job(task_job, detailed: false)
-      data = {
+    def serialize_task_job(task_job)
+      {
         job_id: task_job.job_id,
         task_name: task_job.task_name,
         task_description: task_job.task_description,
@@ -277,22 +299,12 @@ module ForemanOpenbolt
         status: task_job.status,
         smart_proxy: {
           id: task_job.smart_proxy_id,
-          name: task_job.smart_proxy.name,
+          name: task_job.smart_proxy&.name || '(unknown)',
         },
         submitted_at: task_job.submitted_at,
         completed_at: task_job.completed_at,
         duration: task_job.duration,
       }
-
-      if detailed
-        data.merge!(
-          openbolt_options: task_job.scrubbed_openbolt_options,
-          result: task_job.result,
-          log: task_job.log
-        )
-      end
-
-      data
     end
   end
 end

data/app/lib/actions/foreman_openbolt/cleanup_proxy_artifacts.rb

@@ -8,16 +8,19 @@ module Actions
       end
 
       def run
-        proxy = ::SmartProxy.find(input[:proxy_id])
-        api = ::ProxyAPI::Openbolt.new(url: proxy.url)
+        proxy = ::SmartProxy.find_by(id: input[:proxy_id])
+        unless proxy
+          Rails.logger.warn("Proxy #{input[:proxy_id]} not found during cleanup for job #{input[:job_id]}, skipping")
+          return
+        end
 
+        api = ::ProxyAPI::Openbolt.new(url: proxy.url)
         response = api.delete_job_artifacts(job_id: input[:job_id])
-        Rails.logger.info("Cleaned up artifacts for job #{input[:job_id]}: #{response}")
-
-        Rails.logger.info("Would delete artifacts for job #{input[:job_id]} on proxy #{proxy.name}")
+        Rails.logger.debug { "Cleaned up artifacts for job #{input[:job_id]} on proxy #{proxy.name}: #{response}" }
       rescue StandardError => e
         # Don't fail the action if cleanup fails - it's not critical
-        Rails.logger.error("Failed to cleanup artifacts for job #{input[:job_id]}: #{e.message}")
+        Rails.logger.error("Failed to cleanup artifacts for job #{input[:job_id]}: #{e.class}: #{e.message}")
+        Rails.logger.error(e.backtrace.join("\n")) if e.backtrace
       end
 
       def rescue_strategy
@@ -30,10 +33,8 @@ module Actions
       end
 
       def humanized_input
-        {
-          job_id: input[:job_id],
-          proxy: ::SmartProxy.find_by(id: input[:proxy_id])&.name,
-        }
+        proxy_name = ::SmartProxy.find_by(id: input[:proxy_id])&.name || '(unknown)'
+        "job #{input[:job_id]} on #{proxy_name}"
       end
     end
   end