refactor: centralize SVG Rendering via Service Wrapper with Priority-Based Fallback (#2856)

 introduces a **Service Wrapper** for the SVG rendering pipeline, providing a unified and fault-tolerant way to render SVGs.

## Key Changes

- All direct usages of rendering services (**Indigo**, **KetcherSVG**, and **OpenBabel**) have been replaced with a centralized **Service Wrapper**.
- The wrapper automatically handles service selection, prioritization, and fallback.

## Rendering Logic

SVG rendering follows this priority order:
1. **Indigo Service**
2. **KetcherSVG Service**
3. **OpenBabel Service** (fallback)

- If a higher-priority service is **disabled** or **fails to return a successful response**, the wrapper automatically falls back to the next available service.
- If both **Indigo** and **KetcherSVG** are disabled or unavailable, SVG rendering is performed using **OpenBabel**.

Author: haditariq

app/api/chemotion/molecule_api.rb

@@ -70,9 +70,9 @@ class MoleculeAPI < Grape::API
             svg_file_src = Rails.public_path.join('images', 'molecules', molecule.molecule_svg_file)
             if File.exist?(svg_file_src)
               if svg.nil? || svg&.include?('Open Babel')
-                indigo_served_svg = Molecule.svg_reprocess(svg, molecule.molfile)
-                if indigo_served_svg
-                  svg_process = SVG::Processor.new.structure_svg('ketcher', indigo_served_svg, svg_digest, true)
+                svg = Molecule.svg_reprocess(svg, molecule.molfile)
+                if svg
+                  svg_process = SVG::Processor.new.structure_svg('ketcher', svg, svg_digest, true)
                   FileUtils.cp(svg_process[:svg_file_path], svg_file_src)
                 end
               else
@@ -196,8 +196,9 @@ class MoleculeAPI < Grape::API
           if File.exist?(svg_file_src)
             mol = molecule.molfile.lines.first(2)
             if mol[1]&.strip&.match?('OpenBabel')
-              svg = File.read(svg_file_src)
-              svg_process = SVG::Processor.new.structure_svg('openbabel', svg, molfile)
+              svg = Molecule.svg_reprocess(svg, molecule.molfile)
+              svg_digest = "#{molecule.inchikey}#{Time.zone.now}"
+              svg_process = SVG::Processor.new.structure_svg('ketcher', svg, svg_digest, true)
             else
               svg_process = SVG::Processor.new.generate_svg_info('samples', molfile)
               FileUtils.cp(svg_file_src, svg_process[:svg_file_path])
@@ -297,7 +298,7 @@ class MoleculeAPI < Grape::API
         processor = if params[:is_chemdraw]
                       Chemotion::ChemdrawSvgProcessor.new(svg)
                     else
-                      Chemotion::KetcherSvgProcessor.new(svg)
+                      KetcherService::SVGProcessor.new(svg)
                     end
         svg = processor.centered_and_scaled_svg
         molecule = Molecule.find(params[:id])

app/api/chemotion/research_plan_api.rb

@@ -228,14 +228,12 @@ class ResearchPlanAPI < Grape::API
       end
       post :svg do
         svg = params[:svg_file]
-        error!({ error: 'Invalid SVG' }, 422) unless IndigoService.new(nil).valid_indigo_svg?(svg)
         processor = if params[:is_chemdraw]
                       Chemotion::ChemdrawSvgProcessor.new(svg)
                     else
-                      Chemotion::KetcherSvgProcessor.new(svg)
+                      KetcherService::SVGProcessor.new(svg)
                     end
         svg = processor.centered_and_scaled_svg
-
         digest = Digest::SHA256.hexdigest svg
         digest = Digest::SHA256.hexdigest digest
         svg_file_name = "#{digest}.svg"

app/models/molecule.rb

@@ -252,15 +252,10 @@ def unique_molecule_name(new_name)
   end
 
   def self.svg_reprocess(svg, struct)
-    return svg if indigo_disabled?
     return svg if svg_valid_and_not_openbabel?(svg)
 
-    rendered_svg = IndigoService.new(struct, 'image/svg+xml').render_structure
-    rendered_svg || Chemotion::OpenBabelService.svg_from_molfile(struct)
-  end
-
-  def self.indigo_disabled?
-    Rails.configuration.indigo_service.disabled?
+    # Use unified SVG renderer service with fallback chain
+    Chemotion::SvgRenderer.render_svg_from_molfile(struct)
   end
 
   def self.svg_valid_and_not_openbabel?(svg)

app/services/indigo_service.rb

@@ -29,6 +29,13 @@ def initialize(struct, output_format = 'image/svg+xml', options = nil)
     @service_url = Rails.configuration.indigo_service.indigo_service_url
   end
 
+  # Checks if Indigo service is disabled
+  #
+  # @return [Boolean] True if service is disabled, false otherwise
+  def self.disabled?
+    Rails.configuration.indigo_service&.disabled? || false
+  end
+
   # Renders the chemical structure using the Indigo service.
   #
   # @return [String, nil] The rendered SVG (or other format), or nil if rendering fails.

config/initializers/ketcher_service.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# This initializer loads the optional configuration for:
+#   the ketcher rendering service
+
+# Specific
+validations = lambda do |config, service|
+  url = URI.parse(config.send(service)&.url)
+  raise ArgumentError, "Invalid URL: #{url}" unless url.host && %w[http https].include?(url.scheme)
+
+  # set description
+  config.send(service).desc = "service hosted at: #{url}"
+end
+
+# Generic initialization
+service = File.basename(__FILE__, '.rb').to_sym # Service name
+service_setter = :"#{service}=" # Service setter
+ref = "Initializing #{service}:" # Message prefix
+
+Rails.application.configure do
+  config.send(service_setter, config_for(service)) # Load config/.yml
+  validations.call(config, service) # Validate configuration
+# Rescue:
+# - RuntimeError is raised if the file is not found
+# - NoMethodError is raised if the yml file cannot be parsed
+rescue RuntimeError, NoMethodError, ArgumentError, URI::InvalidURIError => e
+  Rails.logger.warn "#{ref} Error while loading configuration #{e.message}"
+  # Create service key or clear config
+  config.send(service_setter, nil)
+ensure
+  # Load default missing configuration if the yml file not found or no config is defined for the environment
+  config.send(service_setter, config_for(:default_missing)) unless config.send(service)
+  Rails.logger.info "#{ref} #{config.send(service).desc}"
+end

config/ketcher_service.yml.example

@@ -0,0 +1,5 @@
+development:
+  :url: 'http://ketchersvc:4000/render'
+
+production:
+  :url: 'http://ketchersvc:4000/render'

lib/chemotion/svg_renderer.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require Rails.root.join('lib/ketcher_service/render_svg.rb')
+
+# rubocop:disable Rails/Output
+module Chemotion
+  # Unified SVG renderer with fallback chain:
+  # 1. IndigoService (if enabled)
+  # 2. KetcherService (if Indigo fails or is disabled)
+  # 3. OpenBabelService (if both fail)
+  class SvgRenderer
+    # Renders SVG from molfile using the full fallback chain:
+    # Indigo -> Ketcher -> OpenBabel
+    #
+    # @param struct [String] The molfile structure to render
+    # @return [String, nil] The rendered SVG, or nil if all services fail
+    def self.render_svg_from_molfile(struct)
+      rendered_svg = indigo_service(struct)
+      return rendered_svg if rendered_svg
+
+      rendered_svg = ketcher_service(struct)
+      return rendered_svg if rendered_svg
+
+      open_babel_service(struct)
+    end
+
+    # Attempts to render SVG using IndigoService
+    #
+    # @param struct [String] The molfile structure to render
+    # @return [String, nil] The rendered SVG, or nil if rendering fails or is disabled
+    def self.indigo_service(struct)
+      if IndigoService.disabled?
+        puts '❌ IndigoService is disabled, falling back to KetcherService'
+        return nil
+      end
+
+      rendered_svg = IndigoService.new(struct, 'image/svg+xml').render_structure
+      if rendered_svg.present?
+        puts '✅ SVG rendered using IndigoService'
+        return rendered_svg
+      end
+
+      puts '❌ IndigoService returned nil or empty, falling back to KetcherService'
+      nil
+    end
+
+    # Attempts to render SVG using KetcherService
+    #
+    # @param struct [String] The molfile structure to render
+    # @return [String, nil] The rendered SVG, or nil if rendering fails or is disabled
+    def self.ketcher_service(struct)
+      if KetcherService.disabled?
+        puts '❌ KetcherService is disabled, falling back to OpenBabelService'
+        return nil
+      end
+
+      rendered_svg = render_svg(struct)
+      if rendered_svg.present?
+        puts '✅ SVG rendered using KetcherService'
+        rendered_svg
+      else
+        puts 'KetcherService returned nil or empty, falling back to OpenBabelService'
+        nil
+      end
+    rescue StandardError => e
+      Rails.logger.error("KetcherService exception: #{e.message}")
+      nil
+    end
+
+    # Attempts to render SVG using OpenBabelService
+    #
+    # @param struct [String] The molfile structure to render
+    # @return [String, nil] The rendered SVG, or nil if rendering fails
+    def self.open_babel_service(struct)
+      rendered_svg = OpenBabelService.svg_from_molfile(struct)
+      if rendered_svg.present?
+        puts '✅ SVG rendered using OpenBabelService'
+        rendered_svg
+      else
+        puts 'OpenBabelService returned nil or empty.'
+        nil
+      end
+    rescue StandardError => e
+      Rails.logger.error("❌ OpenBabelService failed: #{e.message}")
+      nil
+    end
+
+    # Renders SVG from molfile using Ketcher service only
+    #
+    # @param molfile [String] The molfile structure to render
+    # @return [String, nil] The rendered and processed SVG, or nil if rendering fails
+    def self.render_svg(molfile)
+      rendered_svg = KetcherService::RenderSvg.svg(molfile)
+      return nil if rendered_svg.blank?
+
+      svg = KetcherService::SVGProcessor.new(rendered_svg)
+      svg.centered_and_scaled_svg
+    rescue StandardError => e
+      Rails.logger.error("Chemotion::SvgRenderer failed: #{e.message}")
+      nil
+    end
+  end
+  # rubocop:enable Rails/Output
+end

lib/ketcher_service/render_svg.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'json'
+
+module KetcherService
+  # Checks if Ketcher service is disabled
+  #
+  # @return [Boolean] True if service is disabled, false otherwise
+  def self.disabled?
+    Rails.configuration.ketcher_service&.disabled? || false
+  end
+
+  # Use Ketcher-as-a-Service to render molfiles to SVG
+  module RenderSvg
+    def self.call_render_service(url, request)
+      use_ssl = url.instance_of? URI::HTTPS
+      Rails.logger.info("Sending molfile to render service at: #{url} (SSL: #{use_ssl})")
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      res = Net::HTTP.start(url.host, url.port, read_timeout: 1.5, use_ssl: use_ssl) do |http|
+        http.request(request)
+      end
+      finish = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      Rails.logger.info("Render service response: #{res.code} in #{finish - start} seconds")
+      raise Net::HTTPError.new("Server replied #{res.code}.", res) if res.code != '200'
+
+      svg = JSON.parse(res.body)['svg']
+      Rails.logger.info('Render service replied with SVG.')
+      svg
+    rescue Errno::ECONNREFUSED
+      Rails.logger.error('Errno::ECONNREFUSED: ketcher_service unreachable')
+      raise
+    rescue Errno::ENOENT
+      Rails.logger.error('IOError')
+      raise
+    rescue Net::ReadTimeout
+      Rails.logger.error('Timeout.')
+      raise
+    rescue Net::HTTPError
+      Rails.logger.error('HTTP error')
+      raise
+    rescue JSON::ParserError => e
+      Rails.logger.error("Can't parse reply: #{e.message}")
+      raise
+    end
+
+    def self.svg(molfile)
+      url = URI(Rails.configuration.ketcher_service.url)
+      request = Net::HTTP::Post.new(url.path, { 'Content-Type' => 'application/json' })
+      request.body = { molfile: molfile.force_encoding('utf-8') }.to_json
+      svg = RenderSvg.call_render_service(url, request)
+      svg.force_encoding('utf-8')
+    rescue StandardError
+      nil
+    end
+  end
+end