Smsru Laravel Package

Technical Evaluation

Architecture Fit

• Pros:
  • Lightweight, single-purpose package (SMS API integration) aligns with modular Laravel architecture.
  • MIT license enables easy adoption without legal constraints.
  • Simple facade/manager pattern (if implemented) could abstract SMS logic cleanly.
• Cons:
  • Archived status (2018) raises compatibility concerns with modern PHP/Laravel (8.x/9.x/10.x).
  • No Laravel-specific service provider or facade; requires manual integration.
  • No dependents suggests niche or abandoned use case—risk of undocumented edge cases.

Integration Feasibility

• API Wrapping: Can wrap sms.ru API calls (e.g., sending, balance checks) via a Service Class or Facade.
  • Example:

    class SmsRuService {
        public function send(string $phone, string $message): array {
            return (new \SmsRu\Client())->send($phone, $message);
        }
    }
    

• Laravel-Specific Adaptations Needed:
  • Service Provider: Register the client as a singleton.
  • Config Publishing: Expose smsru.php for API credentials/endpoints.
  • Queueable Jobs: Wrap SMS sends in ShouldQueue jobs for async processing.
  • Logging: Instrument API calls for debugging (e.g., Guzzle middleware).

Technical Risk

Key Questions

1. Is sms.ru the primary SMS provider? If not, evaluate alternatives (e.g., Vonage, AWS SNS) with active support.
2. What’s the failure tolerance? Does the app need retries/exponential backoff for SMS API timeouts?
3. Are there compliance requirements? (e.g., GDPR for SMS storage/logging)
4. How will this integrate with existing notification channels? (e.g., Laravel’s Notifiable interface)
5. What’s the cost of maintaining this vs. a modern package? (e.g., spatie/laravel-sms)

Integration Approach

Stack Fit

• PHP/Laravel Compatibility:
  • PHP 8.1+: May require compatibility layers (e.g., str_replace for array_column).
  • Laravel 8+: Use Service Container for dependency injection and Config Files for settings.
• Tooling:
  • Composer: Install via composer require zelenin/smsru.
  • PHPUnit: Write tests for SMS service layer (mock sms.ru API responses).
  • Laravel Mix/Webpack: Not applicable (no frontend assets).

Migration Path

1. Phase 1: Proof of Concept

   • Create a standalone SmsRuService class.
   • Test basic API calls (e.g., sending, balance check) in a local environment.
   • Validate against sms.ru API docs for deprecated endpoints.

2. Phase 2: Laravel Integration

   • Publish config file (config/smsru.php) for credentials.
   • Register a Service Provider to bind the client to the container:

     $this->app->singleton(SmsRuService::class, function ($app) {
         return new SmsRuService(config('smsru.api_key'));
     });
     

   • Create a Facade (optional) for cleaner syntax:

     facade(SmsRu::class, SmsRuService::class);
     

3. Phase 3: Production Readiness

   • Implement retry logic (e.g., Laravel’s retry helper or a custom decorator).
   • Add logging (e.g., Monolog channel for SMS API responses).
   • Containerize the service (if applicable) for CI/CD testing.

Compatibility

• Laravel-Specific Features:
  • Queue Jobs: Extend SmsRuService to support ShouldQueue:

    class SendSmsJob implements ShouldQueue {
        use Dispatchable, InteractsWithQueue;
    
        public function handle() {
            app(SmsRuService::class)->send($this->phone, $this->message);
        }
    }
    

  • Events: Dispatch SmsSent/SmsFailed events for observability.
• Third-Party Risks:
  • Guzzle HTTP Client: If the package uses an outdated version, upgrade via Composer overrides.
  • Carbon: If the package uses Carbon v1, replace with Laravel’s native Carbon.

Sequencing

1. Prerequisites:
   • Ensure sms.ru API credentials are available.
   • Verify PHP version supports the package (or plan polyfills).
2. Dependencies:
   • No hard dependencies, but test with Laravel’s HTTP Client or Queue if using those features.
3. Post-Integration:
   • Monitor sms.ru API status (e.g., uptimeRobot).
   • Set up alerts for SMS delivery failures.

Operational Impact

Maintenance

• Effort Estimate:
  • Low: For basic usage (e.g., sending SMS).
  • Medium-High: For advanced features (e.g., webhooks, template management).
• Tasks:
  • API Monitoring: Track sms.ru rate limits and quotas.
  • Deprecation Alerts: Subscribe to sms.ru changelogs.
  • Package Updates: None expected (archived), but fork if critical fixes are needed.

Support

• Debugging:
  • Enable verbose logging for API requests/responses.
  • Use Laravel Telescope to inspect SMS-related events.
• Common Issues:
  • Authentication Failures: Validate API keys in config.
  • Rate Limiting: Implement exponential backoff in retries.
  • Character Encoding: Ensure UTF-8 compatibility for messages.

Scaling

• Horizontal Scaling:
  • Stateless design (API calls are external) allows scaling Laravel app independently.
• Performance:
  • Async Processing: Offload SMS sends to queues to avoid blocking HTTP requests.
  • Caching: Cache SMS templates or balance checks if frequently accessed.
• Load Testing:
  • Simulate high SMS volumes to test sms.ru API limits.

Failure Modes

Ramp-Up

• Onboarding Time: 1–3 days for basic integration; longer for advanced features.
• Skills Required:
  • PHP/Laravel service development.
  • API testing (Postman/cURL).
  • Basic DevOps (config management, logging).
• Training Needs:
  • Review sms.ru API documentation for edge cases (e.g., international numbers).
  • Familiarize team with Laravel’s Service Container and Queue systems.
• Documentation Gaps:
  • No Laravel-specific docs: Create internal runbooks for setup/deployment.
  • Error Handling: Document expected API error codes (e.g., 402 for insufficient balance).