mistral_translator 0.3.2 → 0.5.0

data/lib/mistral_translator/proxy.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module MistralTranslator
+  # Proxy HTTP optionnel pour joindre l'API. Les identifiants du proxy
+  # ne figurent jamais dans les messages d'erreur.
+  module Proxy
+    # net-http-persistent ignore le schéma du proxy et lui parle toujours en clair :
+    # un proxy https:// enverrait ses identifiants sans chiffrement. Le flux vers
+    # l'API reste chiffré de bout en bout (CONNECT puis TLS).
+    SCHEME = "http"
+    API_PORT = 443
+
+    class << self
+      # nil : pas de proxy ; URI ou String : ce proxy ; :env : variables d'environnement
+      def validate!(setting)
+        return if setting.nil? || setting == :env
+
+        parse!(setting)
+      end
+
+      # URI du proxy à utiliser pour joindre host, ou nil
+      def resolve(setting, host:, env: ENV)
+        return nil if setting.nil?
+        return from_env(host, env) if setting == :env
+
+        parse!(setting)
+      end
+
+      private
+
+      # net-http-persistent ne lit que HTTP_PROXY : HTTPS_PROXY est lu ici, en priorité.
+      def from_env(host, env)
+        value = env_value(env, "https_proxy") || env_value(env, "http_proxy")
+        return nil if value.nil? || bypassed?(host, env_value(env, "no_proxy"))
+
+        parse!(value)
+      end
+
+      # Une variable vide, en minuscules, ne masque pas sa version en majuscules.
+      def env_value(env, name)
+        [env[name], env[name.upcase]].map { |value| value.to_s.strip }.find { |value| !value.empty? }
+      end
+
+      def bypassed?(host, no_proxy)
+        return false if no_proxy.nil?
+
+        no_proxy.split(",").any? { |entry| no_proxy_match?(host.downcase, entry.strip.downcase) }
+      end
+
+      # Comme curl : "*", un domaine et ses sous-domaines, avec ou sans point ou "*." initial.
+      # Une entrée avec un port ne vaut que pour le port de l'API.
+      def no_proxy_match?(host, entry)
+        return false if entry.empty?
+        return true if entry == "*"
+
+        domain, port = entry.split(":", 2)
+        return false if port && port.to_i != API_PORT
+
+        domain = domain.delete_prefix("*").delete_prefix(".")
+        host == domain || host.end_with?(".#{domain}")
+      end
+
+      def parse!(value)
+        uri = URI.parse(value.to_s)
+        return uri if uri.is_a?(URI::HTTP) && uri.scheme == SCHEME && uri.host && !uri.host.empty?
+
+        raise ConfigurationError, "Invalid proxy: expected an http:// URL with a host"
+      rescue URI::InvalidURIError
+        raise ConfigurationError, "Invalid proxy: malformed URL", cause: nil
+      end
+    end
+  end
+end

data/lib/mistral_translator/response_parser.rb

@@ -4,47 +4,61 @@ require_relative "logger"
 
 module MistralTranslator
   class ResponseParser
+    # Emplacements possibles du texte traduit ou résumé, par ordre de priorité
+    TARGET_PATHS = [
+      %w[content target], %w[translation target], %w[target],
+      %w[content translated], %w[translated],
+      %w[content summary], %w[summary]
+    ].freeze
+
+    SOURCE_PATHS = [
+      %w[content source], %w[translation source], %w[source],
+      %w[content original], %w[original]
+    ].freeze
+
+    # Garde-fous contre les réponses démesurées
+    MAX_CONTENT_SIZE = 1_000_000
+    MAX_SCAN_LENGTH = 100_000
+    BRACE_DEPTH = { "{" => 1, "}" => -1 }.freeze
+
     class << self
       def parse_translation_response(raw_content)
         return nil if raw_content.nil? || raw_content.empty?
 
-        begin
-          json_content = extract_json_from_content(raw_content)
-          return nil unless json_content
-
-          translation_data = parse_json_content(json_content)
-          translated_text = extract_target_content(translation_data)
-          validate_translation_content(translated_text)
-
-          build_translation_result(translation_data, translated_text)
-        rescue JSON::ParserError => e
-          handle_json_parse_error(e, raw_content, json_content)
-        rescue EmptyTranslationError
-          raise # Re-raise EmptyTranslationError
-        rescue StandardError => e
-          raise InvalidResponseError, "Error processing response: #{e.message}"
+        with_response_errors("translation", raw_content) do
+          data = parse_response_json(raw_content, "translation")
+          translated_text = target_text!(data, "Empty translation received from API", raw_content)
+
+          build_translation_result(data, translated_text)
         end
       end
 
       def parse_quality_check_response(raw_content)
         return { translation: nil, quality_check: {}, metadata: {} } if raw_content.nil? || raw_content.empty?
 
-        json_content = extract_json_from_content(raw_content)
-        raise InvalidResponseError, "Invalid JSON in quality check response" unless json_content
+        with_response_errors("quality check", raw_content) do
+          data = parse_response_json(raw_content, "quality check")
 
-        data = JSON.parse(json_content)
+          {
+            translation: target_text!(data, "Empty translation received from API", raw_content),
+            quality_check: data["quality_check"] || value_at(data, %w[metadata quality_check]) || {},
+            metadata: metadata_of(data)
+          }
+        end
+      end
 
-        translation = extract_target_content(data)
-        quality = data["quality_check"] || data.dig("metadata", "quality_check") || {}
-        {
-          translation: translation,
-          quality_check: quality,
-          metadata: data["metadata"] || {}
-        }
-      rescue JSON::ParserError
-        raise InvalidResponseError, "Invalid JSON in quality check response"
-      rescue StandardError => e
-        raise InvalidResponseError, "Error processing quality check response: #{e.message}"
+      def parse_summary_response(raw_content)
+        return nil if raw_content.nil? || raw_content.empty?
+
+        with_response_errors("summary", raw_content) do
+          data = parse_response_json(raw_content, "summary")
+
+          {
+            original: extract_source_content(data),
+            summary: target_text!(data, "Empty summary received", raw_content),
+            metadata: metadata_of(data)
+          }
+        end
       end
 
       def parse_json_content(json_content)
@@ -62,234 +76,143 @@ module MistralTranslator
         end
       end
 
-      def validate_translation_content(translated_text)
-        return unless translated_text.nil? || translated_text.empty?
-
-        raise EmptyTranslationError, "Empty translation received from API"
-      end
-
       def build_translation_result(translation_data, translated_text)
         {
           original: extract_source_content(translation_data),
           translated: translated_text,
-          metadata: translation_data["metadata"] || {}
+          metadata: metadata_of(translation_data)
         }
       end
 
-      def handle_json_parse_error(error, raw_content, json_content)
-        error_details = {
-          error_message: error.message,
-          raw_content_length: raw_content&.length,
-          json_content_length: json_content&.length,
-          has_json_content: !json_content.nil?
-        }
-        Logger.debug_if_verbose(
-          "JSON parse failed: #{error.message} raw_len=#{error_details[:raw_content_length]} " \
-          "json_len=#{error_details[:json_content_length]} snippet=#{raw_content&.slice(0, 120)}",
-          sensitive: false
-        )
-        raise InvalidResponseError, "Invalid JSON in response: #{error.message}. Details: #{error_details}"
-      end
-
-      # rubocop:disable Metrics/PerceivedComplexity
-      def parse_summary_response(raw_content)
-        return nil if raw_content.nil? || raw_content.empty?
-
-        begin
-          json_content = extract_json_from_content(raw_content)
-          unless json_content
-            # Aucun JSON détecté: utiliser le texte brut comme repli si non vide
-            text = raw_content.to_s.strip
-            raise EmptyTranslationError, "Empty summary received" if text.empty?
-
-            return {
-              original: nil,
-              summary: text,
-              metadata: { "operation" => "summarization", "fallback" => true }
-            }
-          end
-
-          summary_data = JSON.parse(json_content)
-          summary_text = extract_target_content(summary_data)
-
-          raise EmptyTranslationError, "Empty summary received" if summary_text.nil? || summary_text.empty?
-
-          {
-            original: extract_source_content(summary_data),
-            summary: summary_text,
-            metadata: summary_data["metadata"] || {}
-          }
-        rescue JSON::ParserError
-          # Fallback: si ce n'est pas du JSON, essayer d'utiliser le texte brut s'il a du contenu
-          text = raw_content.to_s.strip
-          raise InvalidResponseError, "Invalid JSON in summary response: #{raw_content}" if text.empty?
+      private
 
-          {
-            original: nil,
-            summary: text,
-            metadata: { "operation" => "summarization", "fallback" => true }
-          }
-        rescue EmptyTranslationError
-          raise # Re-raise EmptyTranslationError
-        rescue StandardError => e
-          raise InvalidResponseError, "Error processing summary response: #{e.message}"
-        end
+      # Les erreurs Ruby (JSON::ParserError, NoMethodError, TypeError…) citent la réponse dans
+      # leur message : ni ce message ni l'erreur d'origine (cause) ne sont repris.
+      # La réponse reste accessible au code appelant via InvalidResponseError#raw_response.
+      def with_response_errors(label, raw_content)
+        yield
+      rescue EmptyTranslationError, InvalidResponseError
+        raise
+      rescue StandardError => e
+        raise InvalidResponseError.new("Error processing #{label} response (#{e.class})", raw_content), cause: nil
       end
-      # rubocop:enable Metrics/PerceivedComplexity
 
-      def parse_bulk_translation_response(raw_content)
-        return [] if raw_content.nil? || raw_content.empty?
+      # Le mode JSON de l'API renvoie un objet seul, lu tel quel. Sinon, on lit le premier objet
+      # trouvé dans le texte, en réparant les continuations de ligne.
+      def parse_response_json(raw_content, label)
+        ensure_content_size!(raw_content)
+        data = parse_whole_or_embedded(raw_content, label)
+        raise InvalidResponseError.new("Unexpected JSON in #{label} response", raw_content) unless data.is_a?(Hash)
 
-        begin
-          json_content = extract_json_from_content(raw_content)
-          raise InvalidResponseError, "Invalid JSON in bulk response: #{raw_content}" unless json_content
-
-          bulk_data = JSON.parse(json_content)
-          translations = bulk_data["translations"]
-
-          raise InvalidResponseError, "No translations array in response" unless translations.is_a?(Array)
-
-          translations.map do |translation|
-            {
-              index: translation["index"],
-              original: translation["source"],
-              translated: translation["target"]
-            }
-          end
-        rescue JSON::ParserError
-          raise InvalidResponseError, "Invalid JSON in bulk response: #{raw_content}"
-        rescue StandardError => e
-          # Ne pas wrapper l'erreur "No translations array in response"
-          raise e if e.message == "No translations array in response"
-
-          raise InvalidResponseError, "Error processing bulk response: #{e.message}"
-        end
+        data
       end
 
-      private
-
-      def extract_json_from_content(content)
-        return nil if content.nil? || content.empty?
+      def ensure_content_size!(content)
+        return if content.length <= MAX_CONTENT_SIZE
 
-        # Limiter la taille pour éviter les attaques DoS
-        max_content_size = 1_000_000 # 1MB max
-        if content.length > max_content_size
-          raise InvalidResponseError, "Response content too large (#{content.length} bytes, max: #{max_content_size})"
-        end
-
-        # Essayer d'abord de parser directement le contenu comme JSON
-        begin
-          JSON.parse(content)
-          content
-        rescue JSON::ParserError
-          # Si ça échoue, chercher le JSON dans la réponse (peut être entouré de texte)
-          # Utiliser une approche plus robuste pour les JSON complexes
-          find_json_in_text(content)
-        end
+        raise InvalidResponseError, "Response content too large (#{content.length} bytes, max: #{MAX_CONTENT_SIZE})"
       end
 
-      def find_json_in_text(text)
-        start_pos = find_json_start(text)
-        return nil unless start_pos
+      def parse_whole_or_embedded(raw_content, label)
+        JSON.parse(raw_content)
+      rescue JSON::ParserError
+        json_content = find_json_in_text(raw_content)
+        raise InvalidResponseError.new("No JSON in #{label} response", raw_content), cause: nil unless json_content
 
-        parse_json_until_end(text, start_pos)
+        parse_embedded_json(json_content, raw_content, label)
       end
 
-      def find_json_start(text)
-        text.index("{")
+      def parse_embedded_json(json_content, raw_content, label)
+        parse_json_content(json_content)
+      rescue JSON::ParserError
+        details = "raw_len=#{raw_content.length} json_len=#{json_content.length}"
+        Logger.debug_if_verbose("JSON parse failed: #{details}", sensitive: false)
+        raise InvalidResponseError.new("Invalid JSON in #{label} response (#{details})", raw_content), cause: nil
       end
 
-      def parse_json_until_end(text, start_pos)
-        parser_state = JsonParserState.new
-        max_iterations = 100_000
+      # Le premier objet du texte, de sa première accolade à celle qui la referme.
+      def find_json_in_text(text)
+        start = text.index("{")
+        finish = closing_brace_index(text, start) if start
+        text[start..finish] if finish
+      end
 
-        (start_pos...text.length).each do |i|
-          parser_state.increment_iterations
-          if parser_state.iterations > max_iterations
-            raise InvalidResponseError,
-                  "JSON parsing exceeded maximum iterations"
+      # Les accolades des chaînes ne comptent pas ; le parcours est plafonné.
+      def closing_brace_index(text, start)
+        depth = 0
+        in_string = false
+        escaped = false
+
+        (start...text.length).each do |index|
+          ensure_scan_length!(index - start)
+          char = text[index]
+
+          if escaped
+            escaped = false
+          elsif char == "\\"
+            escaped = true
+          elsif char == '"'
+            in_string = !in_string
+          elsif !in_string
+            depth += BRACE_DEPTH.fetch(char, 0)
+            return index if depth.zero?
           end
-
-          char = text[i]
-          parser_state.process_character(char)
-
-          return text[start_pos..i] if parser_state.found_complete_json?
         end
 
         nil
       end
 
-      # Helper class pour gérer l'état du parsing JSON
-      class JsonParserState
-        attr_reader :iterations
+      def ensure_scan_length!(scanned)
+        return if scanned < MAX_SCAN_LENGTH
 
-        def initialize
-          @brace_count = 0
-          @in_string = false
-          @escape_next = false
-          @iterations = 0
-        end
-
-        def increment_iterations
-          @iterations += 1
-        end
+        raise InvalidResponseError, "JSON parsing exceeded maximum iterations", cause: nil
+      end
 
-        def process_character(char)
-          return handle_escape_character if @escape_next
-          return handle_backslash_character if char == "\\"
-          return handle_quote_character(char) if char == '"' && !@escape_next
-          return if @in_string
+      # Le texte traduit ou résumé : toujours une String non vide, jamais un objet ou un tableau.
+      def target_text!(data, empty_message, raw_content)
+        target = find_target(data)
+        nested = nested_response(target)
+        target = find_target(nested) || "" if nested && target_candidates(nested).any?
 
-          handle_brace_character(char)
+        unless target.nil? || target.is_a?(String)
+          raise InvalidResponseError.new("Unexpected target in response", raw_content)
         end
+        raise EmptyTranslationError, empty_message if target.to_s.strip.empty?
 
-        def handle_escape_character
-          @escape_next = false
-        end
+        target
+      end
 
-        def handle_backslash_character
-          @escape_next = true
-        end
+      def find_target(data)
+        target_candidates(data).find { |item| !(item.respond_to?(:empty?) && item.empty?) }
+      end
 
-        def handle_quote_character(_char)
-          @in_string = !@in_string
-        end
+      def target_candidates(data)
+        TARGET_PATHS.filter_map { |path| value_at(data, path) }
+      end
 
-        def handle_brace_character(char)
-          if char == "{"
-            @brace_count += 1
-          elsif char == "}"
-            @brace_count -= 1
-          end
-        end
+      # Comme Hash#dig, mais un nœud intermédiaire qui n'est pas un objet donne nil au lieu de TypeError.
+      def value_at(data, path)
+        path.reduce(data) { |node, key| node.is_a?(Hash) ? node[key] : nil }
+      end
 
-        def found_complete_json?
-          @brace_count.zero?
-        end
+      def metadata_of(data)
+        data["metadata"].is_a?(Hash) ? data["metadata"] : {}
       end
 
-      def extract_target_content(data)
-        # Essayer différents chemins possibles pour le contenu traduit
-        [
-          data.dig("content", "target"),
-          data.dig("translation", "target"),
-          data["target"],
-          data.dig("content", "translated"),
-          data["translated"],
-          data.dig("content", "summary"),
-          data["summary"]
-        ].find { |item| item && !item.to_s.empty? }
+      # Le modèle renvoie parfois l'objet de réponse attendu, tel quel ou sérialisé, dans "target" :
+      # on y cherche la cible un niveau plus bas. Un JSON sans clé connue reste une traduction.
+      def nested_response(target)
+        return target if target.is_a?(Hash)
+        return nil unless target.is_a?(String) && target.lstrip.start_with?("{")
+
+        parsed = JSON.parse(target)
+        parsed if parsed.is_a?(Hash)
+      rescue JSON::ParserError
+        nil
       end
 
       def extract_source_content(data)
-        # Essayer différents chemins possibles pour le contenu source
-        [
-          data.dig("content", "source"),
-          data.dig("translation", "source"),
-          data["source"],
-          data.dig("content", "original"),
-          data["original"]
-        ].find { |item| item && !item.to_s.empty? }
+        SOURCE_PATHS.map { |path| value_at(data, path) }.find { |item| item.is_a?(String) && !item.empty? }
       end
     end
   end

data/lib/mistral_translator/retries.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "logger"
+
+module MistralTranslator
+  # Relances communes aux traductions et aux résumés.
+  # Le client relance déjà les 429 avec backoff : ici, quelques tentatives de plus suffisent.
+  module Retries
+    RETRY_COUNT = 3
+    RETRY_DELAY = 2
+
+    private
+
+    # Exécute le bloc, qui reçoit le numéro de tentative (0 pour la première).
+    # Une réponse inexploitable est relancée avec un backoff exponentiel, un quota dépassé
+    # après un délai fixe ; au-delà de RETRY_COUNT relances, l'erreur remonte.
+    # operation et subject nomment la requête dans les journaux, jamais son contenu.
+    def with_retries(operation:, subject:)
+      attempt = 0
+      begin
+        yield attempt
+      rescue EmptyTranslationError, InvalidResponseError => e
+        raise if attempt >= RETRY_COUNT
+
+        wait_time = RETRY_DELAY * (2**attempt)
+        attempt += 1
+        log_retry(operation, subject, e, attempt, wait_time)
+        sleep(wait_time)
+        retry
+      rescue RateLimitError
+        raise if attempt >= RETRY_COUNT
+
+        attempt += 1
+        log_rate_limit_hit(operation, subject)
+        sleep(RETRY_DELAY)
+        retry
+      end
+    end
+
+    def log_retry(operation, subject, error, attempt, wait_time)
+      message = "#{operation} retry #{attempt}/#{RETRY_COUNT} for #{subject} in #{wait_time}s: #{error.message}"
+      Logger.warn_once(message, key: "#{operation}_retry_#{subject}_#{error.class.name}", sensitive: false, ttl: 120)
+    end
+
+    def log_rate_limit_hit(operation, subject)
+      Logger.warn_once("Rate limit hit for #{operation} #{subject}, retrying",
+                       key: "#{operation}_rate_limit_#{subject}", sensitive: false, ttl: 300)
+    end
+  end
+end