mistral_translator 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1736f848f5877e51c319bb4584e110e863a6e44464af7f05133d3ea2e2f96fd6
-  data.tar.gz: bd06e5e900f129e662fb2ca90b5c241e55ac86511710d7c4f0cc373fca6c4c2c
+  metadata.gz: 278978acb1df0d447293200f13ff58745640a62f5bf43a41ebc7b31db2d50b98
+  data.tar.gz: c86fc021d49a554fd4d44883e1383a5ea4ba82251074b4b358b3b5cf97f27fd2
 SHA512:
-  metadata.gz: 3f57b5f9652c5b8327de801d5e391eb41f3c6915a9d4551e4ee57a2a61369ead60cffe1c72a5a35ccf089f23401d41d5685480331fe97786d9af7a661c303349
-  data.tar.gz: 672f5aa7932401c2bae6c2ced94058d60ffb6dfab3fb5d6760896f61ed26e5f4eef7b2491697d6680e544b97612f774b4f6fed95b66d0127984d1863592e1509
+  metadata.gz: ca6e0c3b2e2346ab8432dfc24080adcb994f75df453111851d6f8441465d09107d59216fc84efc1f84acf823a4a4ec284c5d1b1212c8ceda9a3d8861e95a2208
+  data.tar.gz: 39b55072eb24870acd861b8c7ec7c8aa279a9f7b03b4a84f0cdabd4982c2d9f04da1b39b2eea05024d6e3a2c1bc7737ee95557f0eaa588c61ec3fbc5d04af540

data/.env.example

@@ -0,0 +1,3 @@
+# Copy to .env (ignored by git) to run bin/check_api without typing the key.
+# Use a key dedicated to these checks, from a workspace with generation enabled.
+MISTRAL_TEST_API_KEY=

data/CHANGELOG.md

@@ -1,5 +1,44 @@
 ## [Unreleased]
 
+## [0.3.1] - 2026-10-27
+
+### Fixed
+
+- Default model is now `mistral-small-latest`. Mistral retired the `mistral-small` name, so every call without an explicit `config.model` failed with a 404. The alias follows the current Mistral Small version; set `config.model` to pin one.
+
+### Added
+
+- `bin/check_api`: checks the API key and the default model, then runs the examples against the real API when the plan allows generation. The key is read from `MISTRAL_TEST_API_KEY`, `.env`, or a hidden prompt, and never printed.
+- Weekly workflow running `bin/check_api`, which opens an issue on failure.
+
+### Changed
+
+- CI: a single workflow, RuboCop plus the test suite on Ruby 3.2, 3.3, 3.4 and 4.0.
+- The test suite no longer prints part of the API key, and no longer deletes VCR cassettes after each run.
+
+## [0.3.0] - 2025-12-09
+
+### Added
+
+- Thread-safe metrics with Mutex protection for concurrent usage
+- Connection pooling with net-http-persistent (automatic connection reuse)
+- SSL/TLS configuration options: `ssl_verify_mode`, `ssl_ca_file`, `ssl_ca_path`, `ssl_timeout`
+- Thread-safe logger cache for `warn_once` method
+- Comprehensive concurrent/async documentation with SolidQueue, Sidekiq, Concurrent Ruby examples
+- 39 new tests for thread-safety, SSL configuration, and connection pooling
+
+### Changed
+
+- HTTP client now uses Net::HTTP::Persistent for better performance
+- Configuration metrics now thread-safe across concurrent requests
+- Documentation reorganized with SolidQueue as recommended background job backend
+
+### Performance
+
+- Connection pooling reduces TCP handshake overhead
+- Thread-safe implementation enables safe concurrent translations
+- Configurable SSL timeout for production environments
+
 ## [0.2.0] - 2025-09-09
 
 ### Added

data/CONTRIBUTING.md

@@ -0,0 +1,70 @@
+# Contributing to MistralTranslator
+
+Thank you for your interest in contributing to MistralTranslator! We welcome contributions of all kinds.
+
+## Development Setup
+
+### Prerequisites
+
+- Ruby 3.2+
+- Bundler
+
+### Installation
+
+```bash
+git clone https://github.com/your-username/mistral_translator.git
+cd mistral_translator
+bundle install
+```
+
+## Running Tests
+
+```bash
+# Unit tests (no API key required)
+bundle exec rspec
+
+# Integration tests (requires real API key)
+export MISTRAL_API_KEY=your_key && bundle exec rspec spec/integration/mistral_api_integration_spec.rb
+
+# All tests with coverage
+bundle exec rspec --format documentation
+```
+
+## Contributing Guidelines
+
+### Reporting Issues
+
+- Use GitHub Issues for bug reports and feature requests
+- Include Ruby version, gem version, and relevant code snippets
+- For API-related issues, include sanitized request/response examples
+
+### Pull Requests
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/your-feature`
+3. Make your changes with tests
+4. Ensure all tests pass: `bundle exec rspec`
+5. Follow Ruby style conventions (we use RuboCop - no error) : `bundle exec rubocop`
+6. Submit a pull request with a clear description
+
+### Code Standards
+
+- Write tests for new features and bug fixes
+- Follow existing code patterns and architecture
+- Update documentation for public API changes
+- Keep commits atomic and well-described
+
+### Testing
+
+- Unit tests should not require API calls (use mocks/stubs)
+- Integration tests should use VCR cassettes when possible
+- Test edge cases and error conditions
+- Test coverage must be at 100% (for now)
+
+## Release Process
+
+Releases are handled by maintainers following semantic versioning.
+
+## Questions?
+
+Feel free to open an issue for any questions about contributing.

data/LICENSE.txt

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+MIT License
 
-Copyright (c) 2025 PierreArko
+Copyright (c) 2024 Pierre Cherbero (peyochanchan)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,13 +9,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -2,9 +2,11 @@
 
 Ruby gem for AI-powered translation and text summarization using Mistral AI API, with advanced Rails support.
 
-[![Gem Version](https://badge.fury.io/rb/mistral_translator.svg)](https://badge.fury.io/rb/mistral_translator)
-
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Gem Version](https://img.shields.io/gem/v/mistral_translator)](https://rubygems.org/gems/mistral_translator)
+[![Downloads](https://img.shields.io/gem/dt/mistral_translator)](https://rubygems.org/gems/mistral_translator)
+[![CI](https://github.com/Peyochanchan/mistral_translator/actions/workflows/ci.yml/badge.svg)](https://github.com/Peyochanchan/mistral_translator/actions/workflows/ci.yml)
+[![Weekly API check](https://github.com/Peyochanchan/mistral_translator/actions/workflows/weekly-api-check.yml/badge.svg)](https://github.com/Peyochanchan/mistral_translator/actions/workflows/weekly-api-check.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
 
 ## Quick Start
 
@@ -30,7 +32,7 @@ MistralTranslator.translate("Bonjour le monde", from: "fr", to: "en")
 - **Multi-level summarization** with translation
 - **Robust error handling** with automatic retry and fallback
 - **Complete monitoring** with metrics and callbacks
-- **Asynchronous jobs** for background processing
+- **Thread-safe & concurrent** with connection pooling ([docs](https://peyochanchan.github.io/mistral_translator/#/advanced-usage/concurrent-async))
 - **Built-in rate limiting** and security
 
 ## Supported Languages
@@ -157,7 +159,7 @@ MistralTranslator.configure do |config|
   config.api_key = ENV['MISTRAL_API_KEY']
 
   # Optional
-  config.model = "mistral-small"                    # AI model to use
+  config.model = "mistral-small-latest"            # AI model to use (an alias that follows the current Mistral Small)
   config.retry_delays = [1, 2, 4, 8, 16]          # Retry delays in seconds
   config.enable_metrics = true                     # Enable performance metrics
 
@@ -222,29 +224,47 @@ The complete documentation includes:
 
 ### Quick Links
 
-- [Installation & Setup](https://peyochanchan.github.io/mistral_translator/installation)
-- [Rails Integration Guide](https://peyochanchan.github.io/mistral_translator/rails-integration/)
-- [API Methods Reference](https://peyochanchan.github.io/mistral_translator/api-reference/methods)
-- [Error Handling Guide](https://peyochanchan.github.io/mistral_translator/api-reference/errors)
-- [Monitoring Setup](https://peyochanchan.github.io/mistral_translator/advanced-usage/monitoring)
+- [Installation & Setup](https://peyochanchan.github.io/mistral_translator/#/installation)
+- [Rails Integration Guide](https://peyochanchan.github.io/mistral_translator/#/rails-integration/setup)
+- [API Methods Reference](https://peyochanchan.github.io/mistral_translator/#/api-reference/methods)
+- [Error Handling Guide](https://peyochanchan.github.io/mistral_translator/#/api-reference/errors)
+- [Monitoring Setup](https://peyochanchan.github.io/mistral_translator/#/advanced-usage/monitoring)
 
 ## Requirements
 
 - Ruby 3.2+
-- Mistral AI API key
+- Mistral AI API key, on a plan with API access (Mistral's free plan cannot generate text)
 - Rails 6.0+ (optional, for Rails integration features)
 
 ## Testing
 
 ```bash
-# Run tests
-bundle exec rspec
+# Install dependencies
+bundle install
+
+# Run all unit tests (no API key required)
+bundle exec rspec spec/mistral_translator/
+
+# Run all tests with documentation format
+bundle exec rspec --format documentation
+
+# Check the API key and default model, then run the examples against the real
+# API (reads MISTRAL_TEST_API_KEY, .env or asks for the key, never prints it)
+bin/check_api
+```
+
+### Integration Tests
+
+Integration tests require a real Mistral API key. **Never commit API keys to version control.**
+
+```bash
+# Set API key via environment variable (recommended)
+export MISTRAL_API_KEY="your_api_key_here"
 
-# Run with coverage
-COVERAGE=true bundle exec rspec
+# Run integration tests
+bundle exec rspec spec/integration/
 
-# Integration tests (requires API key)
-MISTRAL_API_KEY=your_key bundle exec rspec --tag integration
+**Security Note:** Use a dedicated test API key with limited quotas for integration testing.
 ```
 
 ## Contributing
@@ -259,15 +279,24 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed guidelines.
 
 ## License
 
-MIT License. See [LICENSE](LICENSE) for details.
+MIT License. See [LICENSE](LICENSE.txt) for details.
 
 ## Support
 
 - 📖 [Documentation](https://peyochanchan.github.io/mistral_translator/)
 - 🐛 [Issues](../../issues)
-- 💬 [Discussions](../../discussions)
 - 📧 Support: Create an issue for help
 
+### ☕ Support the Project
+
+If this gem helps you, consider supporting its development:
+
+[![Buy Me A Coffee](https://img.shields.io/badge/Buy%20Me%20A%20Coffee-FFDD00?style=for-the-badge&logo=buy-me-a-coffee&logoColor=black)](https://buymeacoffee.com/peyochanchan)
+
 ---
 
 Built with Ruby ❤️ by [@peyochanchan](https://github.com/peyochanchan)
+
+```
+
+```

data/docs/advanced-usage/concurrent-async.md

@@ -0,0 +1,270 @@
+# Concurrent & Asynchronous Processing
+
+MistralTranslator is thread-safe and optimized for concurrent usage with protected metrics, connection pooling, and built-in rate limiting.
+
+## Thread Safety
+
+**Protected components:**
+- Metrics tracking with Mutex
+- Logger cache with concurrent access control
+- Rate limiter with thread synchronization
+- HTTP connection pooling (Net::HTTP::Persistent)
+
+## Ruby Threads
+
+### Basic Usage
+
+```ruby
+languages = ['fr', 'es', 'de', 'it']
+threads = languages.map do |lang|
+  Thread.new do
+    MistralTranslator.translate("Hello", from: 'en', to: lang)
+  rescue MistralTranslator::Error => e
+    { error: e.message }
+  end
+end
+
+results = threads.map(&:value)
+```
+
+### Thread Pool Pattern
+
+```ruby
+# Safe: Limited threads
+texts.each_slice(5) do |batch|
+  threads = batch.map { |t| Thread.new { translate(t) } }
+  threads.each(&:join)
+end
+
+# Dangerous: Unlimited threads can exhaust memory
+texts.map { |t| Thread.new { translate(t) } }  # Avoid this
+```
+
+## Concurrent Ruby (Recommended)
+
+### Installation
+
+```ruby
+# Gemfile
+gem 'concurrent-ruby', '~> 1.2'
+```
+
+### Fixed Thread Pool
+
+```ruby
+require 'concurrent'
+
+pool = Concurrent::FixedThreadPool.new(5)
+
+futures = languages.map do |lang|
+  Concurrent::Future.execute(executor: pool) do
+    MistralTranslator.translate(text, from: 'en', to: lang)
+  end
+end
+
+results = futures.map(&:value)
+
+pool.shutdown
+pool.wait_for_termination
+```
+
+### Promise Chains
+
+```ruby
+promise = Concurrent::Promise.execute do
+  MistralTranslator.translate_auto(text, to: 'en')
+end.then do |english|
+  target_langs.map do |lang|
+    MistralTranslator.translate(english, from: 'en', to: lang)
+  end
+end.rescue do |error|
+  Rails.logger.error "Pipeline failed: #{error}"
+  []
+end
+
+results = promise.value
+```
+
+## Background Jobs
+
+### SolidQueue (Rails 8+, Recommended)
+
+SolidQueue is the default ActiveJob backend in Rails 8, database-backed and Redis-free.
+
+```ruby
+# config/database.yml - SolidQueue uses your existing database
+production:
+  primary:
+    <<: *default
+  queue:  # Separate DB for jobs (optional)
+    <<: *default
+    database: app_queue
+    migrations_paths: db/queue_migrate
+
+# app/jobs/translation_job.rb
+class TranslationJob < ApplicationJob
+  queue_as :translations
+
+  retry_on MistralTranslator::RateLimitError, wait: :polynomially_longer
+  retry_on MistralTranslator::ApiError, wait: 5.seconds, attempts: 3
+
+  def perform(text, from_locale, to_locale)
+    MistralTranslator.translate(text, from: from_locale, to: to_locale)
+  end
+end
+
+# Usage
+languages.each { |lang| TranslationJob.perform_later(text, 'en', lang) }
+```
+
+**Configuration:**
+```ruby
+# config/recurring.yml - Schedule periodic translations
+production:
+  sync_translations:
+    class: TranslationSyncJob
+    schedule: every day at 3am
+    queue: translations
+```
+
+### Sidekiq / Other Backends
+
+Compatible with any ActiveJob backend:
+
+```ruby
+class TranslationJob < ApplicationJob
+  queue_as :translations
+  retry_on MistralTranslator::RateLimitError, wait: :exponentially_longer
+
+  def perform(text, from, to)
+    MistralTranslator.translate(text, from: from, to: to)
+  end
+end
+```
+
+## Performance Best Practices
+
+### Configuration for Concurrent Use
+
+```ruby
+MistralTranslator.configure do |config|
+  config.enable_metrics = true
+  config.retry_delays = [1, 2, 4, 8]  # Shorter for concurrent use
+
+  config.on_rate_limit = ->(from, to, wait, attempt, ts) {
+    Rails.logger.warn "Rate limit: #{wait}s wait"
+  }
+end
+```
+
+### Recommendations
+
+**Do:**
+- Use fixed thread pools (5-10 threads)
+- Enable metrics for monitoring
+- Use background jobs for non-critical tasks
+- Batch similar requests
+
+**Avoid:**
+- Unlimited thread creation
+- Blocking user requests with translations
+- Sharing API keys across environments
+
+## Rate Limiting
+
+The built-in rate limiter (50 requests/60s) is thread-safe but per-process.
+
+**Multiple processes:** Each has its own limiter. With 4 Puma workers = 200 requests/min total.
+
+### Custom Rate Limiter
+
+```ruby
+class RedisRateLimiter
+  def wait_and_record!
+    key = "mistral:#{Time.now.to_i / 60}"
+    count = REDIS.incr(key)
+    REDIS.expire(key, 60) if count == 1
+
+    sleep(60 - Time.now.to_i % 60) if count > 50
+  end
+end
+
+client = MistralTranslator::Client.new(
+  rate_limiter: RedisRateLimiter.new
+)
+```
+
+## Monitoring
+
+```ruby
+MistralTranslator.configure do |config|
+  config.enable_metrics = true
+
+  config.on_translation_complete = ->(from, to, orig, trans, duration) {
+    Rails.logger.info "[#{Thread.current.object_id}] #{from}→#{to}: #{duration.round(2)}s"
+  }
+end
+
+# Thread-safe metrics
+metrics = MistralTranslator.metrics
+puts "Total: #{metrics[:total_translations]}"
+puts "Avg time: #{metrics[:average_translation_time]}s"
+puts "Error rate: #{metrics[:error_rate]}%"
+```
+
+## Example: High-Performance Service
+
+```ruby
+class TranslationService
+  def initialize(max_threads: 5)
+    @pool = Concurrent::FixedThreadPool.new(max_threads)
+  end
+
+  def translate_all(texts, from:, to_languages:)
+    futures = texts.flat_map do |text|
+      to_languages.map do |lang|
+        Concurrent::Future.execute(executor: @pool) do
+          MistralTranslator.translate(text, from: from, to: lang)
+        end
+      end
+    end
+    futures.map(&:value)
+  ensure
+    @pool.shutdown
+    @pool.wait_for_termination(30)
+  end
+end
+```
+
+## Troubleshooting
+
+**"Too many open files"**
+```bash
+ulimit -n 4096
+```
+
+**Rate limits despite low volume**
+Check if multiple processes share the API key. Consider Redis-based rate limiting.
+
+**Memory growth**
+```ruby
+# Join threads periodically
+threads = []
+texts.each do |text|
+  threads << Thread.new { translate(text) }
+
+  if threads.size >= 10
+    threads.each(&:join)
+    threads.clear
+  end
+end
+```
+
+## Summary
+
+- Thread-safe with protected metrics and configuration
+- Connection pooling automatic with net-http-persistent
+- Use fixed-size thread pools (5-10 recommended)
+- Built-in rate limiting works across threads
+- Background jobs recommended for non-critical tasks
+- Separate API keys per environment

data/docs/api-reference/configuration.md

@@ -11,7 +11,7 @@ Référence complète des options de configuration.
 ```ruby
 MistralTranslator.configure do |config|
   config.api_key = ENV['MISTRAL_API_KEY']        # Obligatoire
-  config.model = "mistral-small"                 # Défaut
+  config.model = "mistral-small-latest"                 # Défaut
   config.api_url = "https://api.mistral.ai"      # URL API
   config.default_max_tokens = 4000               # Limite tokens
   config.default_temperature = 0.3               # Créativité (0-1)

data/docs/api-reference/methods.md

@@ -268,7 +268,7 @@ Configure la gem avec un bloc.
 ```ruby
 MistralTranslator.configure do |config|
   config.api_key = ENV['MISTRAL_API_KEY']
-  config.model = "mistral-small"
+  config.model = "mistral-small-latest"
   config.retry_delays = [1, 2, 4, 8]
   config.enable_metrics = true
 end

data/docs/installation.md

@@ -76,7 +76,7 @@ end
 ```ruby
 MistralTranslator.configure do |config|
   config.api_key = ENV['MISTRAL_API_KEY']
-  config.model = "mistral-small"                # Modèle par défaut
+  config.model = "mistral-small-latest"                # Modèle par défaut
   config.retry_delays = [2, 4, 8, 16]          # Délais retry
   config.enable_metrics = true                  # Suivi des stats
   config.default_max_tokens = 4000              # Limite tokens

data/lib/mistral_translator/client_helpers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "net/http/persistent"
+
 module MistralTranslator
   module ClientHelpers
     # Helper pour la gestion des requêtes HTTP
@@ -9,14 +11,10 @@ module MistralTranslator
 
         request_body = build_request_body(prompt, max_tokens, temperature)
 
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = (uri.scheme == "https")
-        http.read_timeout = 60 # 60 secondes de timeout
-
         request = Net::HTTP::Post.new(uri.path, headers)
         request.body = request_body.to_json
 
-        response = http.request(request)
+        response = http_pool.request(uri, request)
         log_request_response(request_body, response)
 
         response
@@ -26,6 +24,38 @@ module MistralTranslator
         raise ApiError, "HTTP error: #{e.message}"
       end
 
+      def http_pool
+        @http_pool ||= begin
+          pool = Net::HTTP::Persistent.new(name: "mistral_translator")
+          pool.read_timeout = 60
+          pool.idle_timeout = 30
+          pool.open_timeout = MistralTranslator.configuration.ssl_timeout
+          pool.max_requests = 100
+
+          # SSL/TLS configuration
+          configure_ssl(pool)
+
+          pool
+        end
+      end
+
+      def configure_ssl(pool)
+        config = MistralTranslator.configuration
+
+        # SSL verify mode
+        pool.verify_mode = case config.ssl_verify_mode
+                           when :peer then OpenSSL::SSL::VERIFY_PEER
+                           when :none then OpenSSL::SSL::VERIFY_NONE
+                           else config.ssl_verify_mode
+                           end
+
+        # Custom CA certificate file
+        pool.ca_file = config.ssl_ca_file if config.ssl_ca_file
+
+        # Custom CA certificates directory
+        pool.ca_path = config.ssl_ca_path if config.ssl_ca_path
+      end
+
       def build_request_body(prompt, max_tokens, temperature)
         body = {
           model: @model,

data/lib/mistral_translator/configuration.rb

@@ -4,13 +4,14 @@ module MistralTranslator
   class Configuration
     attr_accessor :api_key, :model, :default_max_tokens, :default_temperature, :retry_delays,
                   :on_translation_start, :on_translation_complete, :on_translation_error,
-                  :on_rate_limit, :on_batch_complete, :enable_metrics
+                  :on_rate_limit, :on_batch_complete, :enable_metrics,
+                  :ssl_verify_mode, :ssl_ca_file, :ssl_ca_path, :ssl_timeout
     attr_reader :api_url
 
     def initialize
       @api_key = nil
       @api_url = "https://api.mistral.ai"
-      @model = "mistral-small"
+      @model = "mistral-small-latest"
       @default_max_tokens = nil
       @default_temperature = nil
       @retry_delays = [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
@@ -23,7 +24,14 @@ module MistralTranslator
       @on_batch_complete = nil
       @enable_metrics = false
 
-      # Métriques intégrées
+      # SSL/TLS configuration
+      @ssl_verify_mode = :peer  # :peer, :none, or OpenSSL constant
+      @ssl_ca_file = nil        # Path to CA certificate file
+      @ssl_ca_path = nil        # Path to CA certificates directory
+      @ssl_timeout = 60         # SSL handshake timeout in seconds
+
+      # Métriques intégrées (thread-safe avec mutex)
+      @metrics_mutex = Mutex.new
       @metrics = {
         total_translations: 0,
         total_characters: 0,
@@ -54,9 +62,11 @@ module MistralTranslator
 
       return unless @enable_metrics
 
-      @metrics[:total_translations] += 1
-      @metrics[:total_characters] += text_length
-      @metrics[:translations_by_language]["#{from_locale}->#{to_locale}"] += 1
+      @metrics_mutex.synchronize do
+        @metrics[:total_translations] += 1
+        @metrics[:total_characters] += text_length
+        @metrics[:translations_by_language]["#{from_locale}->#{to_locale}"] += 1
+      end
     end
 
     def trigger_translation_complete(from_locale, to_locale, original_length, translated_length, duration)
@@ -64,7 +74,9 @@ module MistralTranslator
 
       return unless @enable_metrics
 
-      @metrics[:total_duration] += duration
+      @metrics_mutex.synchronize do
+        @metrics[:total_duration] += duration
+      end
     end
 
     def trigger_translation_error(from_locale, to_locale, error, attempt)
@@ -72,7 +84,9 @@ module MistralTranslator
 
       return unless @enable_metrics
 
-      @metrics[:errors_count] += 1
+      @metrics_mutex.synchronize do
+        @metrics[:errors_count] += 1
+      end
     end
 
     def trigger_rate_limit(from_locale, to_locale, wait_time, attempt)
@@ -80,7 +94,9 @@ module MistralTranslator
 
       return unless @enable_metrics
 
-      @metrics[:rate_limits_hit] += 1
+      @metrics_mutex.synchronize do
+        @metrics[:rate_limits_hit] += 1
+      end
     end
 
     def trigger_batch_complete(batch_size, total_duration, success_count, error_count)
@@ -91,35 +107,40 @@ module MistralTranslator
     def metrics
       return {} unless @enable_metrics
 
-      @metrics.merge({
-                       average_translation_time: if @metrics[:total_translations].positive?
-                                                   (@metrics[:total_duration] / @metrics[:total_translations]).round(3)
-                                                 else
-                                                   0
-                                                 end,
-                       average_characters_per_translation: if @metrics[:total_translations].positive?
-                                                             (@metrics[:total_characters] /
-                                                               @metrics[:total_translations]).round(0)
-                                                           else
-                                                             0
-                                                           end,
-                       error_rate: if @metrics[:total_translations].positive?
-                                     ((@metrics[:errors_count].to_f / @metrics[:total_translations]) * 100).round(2)
-                                   else
-                                     0
-                                   end
-                     })
+      @metrics_mutex.synchronize do
+        @metrics.merge({
+                         average_translation_time: if @metrics[:total_translations].positive?
+                                                     (@metrics[:total_duration] /
+                                                       @metrics[:total_translations]).round(3)
+                                                   else
+                                                     0
+                                                   end,
+                         average_characters_per_translation: if @metrics[:total_translations].positive?
+                                                               (@metrics[:total_characters] /
+                                                                 @metrics[:total_translations]).round(0)
+                                                             else
+                                                               0
+                                                             end,
+                         error_rate: if @metrics[:total_translations].positive?
+                                       ((@metrics[:errors_count].to_f / @metrics[:total_translations]) * 100).round(2)
+                                     else
+                                       0
+                                     end
+                       })
+      end
     end
 
     def reset_metrics!
-      @metrics = {
-        total_translations: 0,
-        total_characters: 0,
-        total_duration: 0.0,
-        rate_limits_hit: 0,
-        errors_count: 0,
-        translations_by_language: Hash.new(0)
-      }
+      @metrics_mutex.synchronize do
+        @metrics = {
+          total_translations: 0,
+          total_characters: 0,
+          total_duration: 0.0,
+          rate_limits_hit: 0,
+          errors_count: 0,
+          translations_by_language: Hash.new(0)
+        }
+      end
     end
 
     # Configuration helpers pour les callbacks les plus communs

data/lib/mistral_translator/logger.rb

@@ -17,12 +17,15 @@ module MistralTranslator
 
       # Log seulement si pas déjà loggé récemment (évite la spam)
       def warn_once(message, key: nil, sensitive: false, ttl: 300)
-        @warn_cache ||= {}
-        cache_key = key || message
+        cache_mutex.synchronize do
+          @warn_cache ||= {}
+          cache_key = key || message
 
-        return unless should_log_warning?(cache_key, ttl)
+          return unless should_log_warning?(cache_key, ttl)
+
+          @warn_cache[cache_key] = Time.now
+        end
 
-        @warn_cache[cache_key] = Time.now
         log(:warn, message, sensitive)
       end
 
@@ -74,6 +77,10 @@ module MistralTranslator
 
         Time.now - @warn_cache[key] > ttl
       end
+
+      def cache_mutex
+        @cache_mutex ||= Mutex.new
+      end
     end
   end
 end

data/lib/mistral_translator/version.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module MistralTranslator
-  VERSION = "0.2.1"
+  VERSION = "0.3.1"
 
   # Informations additionnelles sur la gem
   API_VERSION = "v1"
-  SUPPORTED_MODEL = "mistral-small"
+  SUPPORTED_MODEL = "mistral-small-latest"
 
   # Méthode pour obtenir des informations complètes sur la version
   def self.version_info

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: mistral_translator
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
-- Peyochanchan
+- Pierre Cherbero
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -103,11 +117,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".env.example"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
 - LICENSE.txt
 - README.md
 - README_TESTING.md
@@ -117,6 +133,7 @@ files:
 - docs/404.html
 - docs/README.md
 - docs/advanced-usage/batch-processing.md
+- docs/advanced-usage/concurrent-async.md
 - docs/advanced-usage/error-handling.md
 - docs/advanced-usage/monitoring.md
 - docs/advanced-usage/summarization.md
@@ -180,7 +197,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 4.0.5
 specification_version: 4
 summary: Gem to translate and summarize text with Mistral API
 test_files: []