Documentation

use ErrorExplorer\ErrorReporter\ErrorReporter;

use ErrorExplorer\ErrorReporter\Enum\LogLevel;

use Psr\Log\LoggerInterface;

class OrderProcessingService

{

public function __construct(

private ErrorReporter $errorReporter,

private LoggerInterface $logger,

private PaymentGateway $paymentGateway

) {}

public function processOrder(Order $order): bool

{

// Breadcrumb pour tracer le processus

$this->errorReporter->addBreadcrumb([

'message' => 'Starting order processing',

'category' => 'order.processing',

'data' => [

'order_id' => $order->getId(),

'total_amount' => $order->getTotal(),

'customer_id' => $order->getCustomer()->getId()

]

]);

try {

// Validation de la commande

if (!$order->isValid()) {

throw new \InvalidArgumentException('Invalid order state');

}

// Traitement du paiement avec retry logic

$paymentResult = $this->processPayment($order);

if ($paymentResult->isSuccessful()) {

$this->logger->info('Order processed successfully', [

'order_id' => $order->getId()

]);

return true ;

}

return false ;

} catch (\Exception $exception) {

// Capture avec contexte service complet

$this->errorReporter->captureException($exception, [

'level' => LogLevel::ERROR,

'tags' => ['order', 'payment', 'critical'],

'fingerprint' => ['order.processing.error', $order->getId()],

'extra' => [

'order_data' => $order->toArray(),

'payment_gateway' => $this->paymentGateway->getName(),

'retry_count' => $this->getCurrentRetryCount()

]

]);

throw $exception;

}

}

}

use Symfony\Component\Console\Attribute\AsCommand;

use Symfony\Component\Console\Command\Command;

use ErrorExplorer\ErrorReporter\ErrorReporter;

#[AsCommand(

name: 'app:process-orders',

description: 'Process pending orders with monitoring'

)]

class ProcessOrdersCommand extends Command

{

public function __construct(

private ErrorReporter $errorReporter,

private OrderRepository $orderRepository

) {

parent ::__construct();

}

protected function execute(InputInterface $input, OutputInterface $output): int

{

$startTime = microtime(true);

$processedCount = 0;

// Configuration du monitoring pour command

$this->errorReporter->configureScope([

'tags' => ['command', 'batch_processing'],

'extra' => [

'command_name' => 'app:process-orders',

'started_at' => date('Y-m-d H:i:s'),

'memory_limit' => ini_get('memory_limit')

]

]);

try {

$pendingOrders = $this->orderRepository->findPendingOrders();

$output->writeln(sprintf('Processing %d orders...', count($pendingOrders)));

foreach ($pendingOrders as $order) {

try {

$this->processOrder($order);

$processedCount++;

} catch (\Exception $e) {

// Capture mais continue le traitement

$this->errorReporter->captureException($e, [

'tags' => ['order_processing_error'],

'extra' => ['order_id' => $order->getId()]

]);

}

}

// Rapport de fin avec métriques

$executionTime = microtime(true) - $startTime;

$this->errorReporter->captureMessage('Command completed', 'info', [

'processed_orders' => $processedCount,

'execution_time_seconds' => round($executionTime, 2),

'memory_peak_mb' => round(memory_get_peak_usage(true) / 1024 / 1024, 2)

]);

return Command::SUCCESS;

} catch (\Exception $exception) {

// Erreur critique de command

$this->errorReporter->captureException($exception, [

'level' => 'error',

'tags' => ['command_failure', 'critical'],

'extra' => [

'processed_before_failure' => $processedCount,

'execution_time' => microtime(true) - $startTime

]

]);

return Command::FAILURE;

}

}

}

use ErrorExplorer\LaravelErrorReporter\Facades\ErrorReporter;

use Illuminate\Contracts\Queue\ShouldQueue;

class ProcessOrderJob implements ShouldQueue

{

public function handle(): void

{

// Track job start avec breadcrumb

ErrorReporter:: addBreadcrumb (

'Job processing started',

'job',

'info',

['order_id' => $this ->orderId, 'queue' => $this ->queue]

);

try {

$this ->processOrder();

} catch (\Exception $e) {

// Report job failure avec contexte

ErrorReporter:: reportError ($e, 'production', 500);

throw $e; // Re-throw pour Laravel

}

}

}

use ErrorExplorer\LaravelErrorReporter\Facades\ErrorReporter;

class ErrorTracking

{

public function handle($request, Closure $next)

{

$startTime = microtime (true);

// Track navigation path

ErrorReporter:: logNavigation ($request->path());

// Track user actions critiques

if ($request->isMethod('POST')) {

ErrorReporter:: logUserAction (

'Critical POST action',

['route' => $request->route()?->getName()]

);

}

$response = $next ($request);

// Monitor slow requests

$duration = ( microtime (true) - $startTime) * 1000;

if ($duration > 2000) {

ErrorReporter:: reportMessage (

'Slow request detected',

'production',

200,

null,

'warning',

['duration_ms' => $duration, 'route' => $request->path()]

);

}

return $response;

}

}

use ErrorExplorer\LaravelErrorReporter\Facades\ErrorReporter;

use Illuminate\Validation\ValidationException;

class CheckoutController extends Controller

{

public function processPayment($userId, $amount)

{

// Track étape critique qui peut échouer

ErrorReporter:: addBreadcrumb (

'Payment process initiated',

'payment',

'info',

['user_id' => $userId, 'amount' => $amount]

);

try {

ErrorReporter:: addBreadcrumb ('Validating user', 'validation');

$user = $this ->validateUser($userId);

ErrorReporter:: addBreadcrumb (

'Processing payment',

'payment',

'info',

['amount' => $amount]

);

return $this->paymentService->charge($user, $amount);

} catch (ValidationException $e) {

ErrorReporter::reportMessage(

'User validation failed',

'production',

400,

null,

'error',

['user_id' => $userId, 'errors' => $e->errors()]

);

throw $e;

}

}

}

// Initialisation Error Explorer pour WordPress

add_action ('init', 'init_error_explorer');

function init_error_explorer() {

// Configuration Error Explorer

if ( function_exists ('error_explorer_init')) {

error_explorer_init ([

'dsn' => 'https://your-dsn@error-explorer.com/project',

'environment' => wp_get_environment_type(),

'release' => get_bloginfo('version'),

'user_context' => [

'id' => get_current_user_id(),

'username' => wp_get_current_user()->user_login ?? 'guest'

]

]);

}

}

// Hook pour capturer les erreurs fatales

add_action ('wp_fatal_error_handler', 'capture_fatal_errors');

function capture_fatal_errors($error) {

if ( function_exists ('error_explorer_capture_exception')) {

error_explorer_capture_exception ( new Exception($error['message']), [

'tags' => [

'wordpress' => get_bloginfo('version'),

'theme' => get_template(),

'type' => 'fatal_error'

],

'extra' => [

'file' => $error['file'] ?? 'unknown',

'line' => $error['line'] ?? 0,

'request_uri' => $_SERVER['REQUEST_URI'] ?? '/'

]

]);

}

}

// Tracer les connexions utilisateur

add_action ('wp_login', 'track_user_login', 10, 2);

function track_user_login($user_login, $user) {

if ( function_exists ('error_explorer_add_breadcrumb')) {

error_explorer_add_breadcrumb ([

'message' => 'User logged in: ' . $user_login,

'category' => 'auth',

'level' => 'info',

'data' => [

'user_id' => $user->ID,

'user_role' => implode(', ', $user->roles),

'login_time' => current_time('mysql')

]

]);

}

}

/**

* Plugin Name: Mon Plugin WordPress

* Description: Plugin avec intégration Error Explorer

* Version: 1.0.0

*/

class MyWordPressPlugin {

public function __construct() {

// Hook d'activation du plugin

register_activation_hook (__FILE__, [$this, 'activate']);

// Hooks principaux

add_action ('init', [$this, 'init']);

add_action ('wp_ajax_my_plugin_action', [$this, 'handle_ajax']);

}

public function activate() {

try {

// Création des tables ou configurations

$this->create_plugin_tables();

// Notification de succès à Error Explorer

if ( function_exists ('error_explorer_capture_message')) {

error_explorer_capture_message (

'Plugin activated successfully',

'info',

[

'plugin' => 'my-wordpress-plugin',

'version' => '1.0.0',

'wordpress_version' => get_bloginfo('version')

]

);

}

} catch (Exception $e) {

// Capture des erreurs d'activation

if ( function_exists ('error_explorer_capture_exception')) {

error_explorer_capture_exception ($e, [

'tags' => [

'plugin' => 'my-wordpress-plugin',

'context' => 'activation',

'severity' => 'high'

]

]);

}

throw $e;

}

}

public function handle_ajax() {

// Vérification de sécurité

if (! wp_verify_nonce ($_POST['nonce'], 'my_plugin_nonce')) {

wp_die ('Security check failed');

}

try {

// Logique métier du plugin

$result = $this->process_user_data($_POST['data']);

wp_send_json_success ($result);

} catch (Exception $e) {

// Capture des erreurs AJAX

if ( function_exists ('error_explorer_capture_exception')) {

error_explorer_capture_exception ($e, [

'tags' => ['ajax', 'plugin'],

'extra' => [

'action' => 'my_plugin_action',

'user_id' => get_current_user_id(),

'post_data' => $_POST

]

]);

}

wp_send_json_error ('Plugin error: ' . $e->getMessage());

}

}

}

// Initialisation du plugin

new MyWordPressPlugin();

/**

* Theme: Mon Thème WordPress

* Error Explorer Integration

*/

class ThemeErrorExplorer {

public function __construct() {

// Configuration du thème avec Error Explorer

add_action ('after_setup_theme', [$this, 'setup_theme']);

add_action ('wp_enqueue_scripts', [$this, 'enqueue_assets']);

add_action ('template_redirect', [$this, 'track_page_views']);

}

public function setup_theme() {

try {

// Support des fonctionnalités du thème

add_theme_support ('post-thumbnails');

add_theme_support ('custom-logo');

// Enregistrement des menus

register_nav_menus ([

'primary' => __('Primary Menu', 'my-theme'),

'footer' => __('Footer Menu', 'my-theme')

]);

} catch (Exception $e) {

// Capture des erreurs de configuration du thème

$this->capture_theme_error($e, 'theme_setup');

}

}

public function enqueue_assets() {

try {

// Chargement des styles et scripts

wp_enqueue_style (

'theme-style',

get_stylesheet_uri (),

[],

wp_get_theme ()->get('Version')

);

wp_enqueue_script (

'theme-script',

get_template_directory_uri () . '/assets/js/theme.js',

['jquery'],

wp_get_theme ()->get('Version'),

true

);

} catch (Exception $e) {

// Capture des erreurs de chargement d'assets

$this->capture_theme_error($e, 'asset_loading');

}

}

public function track_page_views() {

// Traçage des vues de pages pour analytics

if ( function_exists ('error_explorer_add_breadcrumb')) {

global $wp_query;

error_explorer_add_breadcrumb ([

'message' => 'Page viewed: ' . get_the_title(),

'category' => 'navigation',

'level' => 'info',

'data' => [

'page_id' => get_the_ID(),

'page_type' => $this->get_page_type(),

'template' => get_page_template_slug(),

'theme' => get_template(),

'user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? 'unknown'

]

]);

}

}

private function capture_theme_error($exception, $context) {

if ( function_exists ('error_explorer_capture_exception')) {

error_explorer_capture_exception ($exception, [

'tags' => [

'theme' => get_template(),

'context' => $context,

'wordpress' => get_bloginfo('version')

],

'extra' => [

'theme_version' => wp_get_theme()->get('Version'),

'template_hierarchy' => $this->get_template_hierarchy(),

'current_page' => get_the_ID()

]

]);

}

}

private function get_page_type() {

if ( is_front_page ()) return 'home';

if ( is_single ()) return 'single';

if ( is_page ()) return 'page';

if ( is_archive ()) return 'archive';

return 'other';

}

}

// Initialisation du gestionnaire d'erreurs du thème

new ThemeErrorExplorer();