Enable Debugbar in your `.env` file (`APP_DEBUG=true`). The Debugbar will appear at the bottom of your browser window in development. It provides insights into requests, queries, views, and more.
-
**Logging:**
Use `Debugbar::info()`, `Debugbar::error()`, etc., to log custom messages and variables to the Debugbar's messages tab.
2. `dd()` and `dump()`:
- `dd()` (dump and die): This function outputs the contents of a variable and halts script execution. It is useful for quickly inspecting variables at a specific point in the package's code.
Code
```
dd($variable);
```
- `dump()`: Similar to `dd()`, but it does not halt execution, allowing the script to continue. The output appears in the browser or terminal.
Code
```
dump($variable);
```
3. XDebug:
-
**Installation and Configuration:**
Install XDebug for your PHP environment and configure it to work with your IDE (e.g., VS Code). This typically involves setting up a `launch.json` file in VS Code and ensuring the XDebug port matches your configuration.
-
**Breakpoints:**
XDebug allows you to set breakpoints within your package's code. When execution reaches a breakpoint, it pauses, allowing you to inspect variables, step through the code line by line, and understand the flow.
4. Logging:
- **Laravel's Log Facade:** Utilize Laravel's built-in logging system to write messages and variable values to the log files (typically `storage/logs`). This is helpful for tracing execution flow and identifying issues in a non-interactive manner.
Code
```
use Illuminate\Support\Facades\Log;
Log::info('Debugging package functionality.', ['data' => $someData]);
```
5. Ray Desktop Debugging:
-
**Installation:**
Install the Ray desktop application and the `spatie/laravel-ray` package in your Laravel project.
-
**Usage:**
Ray allows you to send data from your application to the desktop app for inspection. It offers a more structured and interactive way to debug than simple `dump()` calls, especially for complex objects and arrays.
Code
```
ray($variable);
ray()->mailable(new MyMailable()); // Example for mailables
```
6. Collection Debugging:
- When working with Laravel Collections within a package, chain `dump()` calls after each collection method to inspect the intermediate results at each step of the chain.
Code
```
$collection->filter(...)
->dump() // Inspect after filter
->map(...)
->dump() // Inspect after map
->get();
```
# How do you debug a Laravel application running on a production server?
Debugging a Laravel application in production requires a cautious approach that prioritizes stability and security. The most effective methods involve using **robust logging**, specialized **error tracking services**, and the built-in `artisan tinker` command, while ensuring `APP_DEBUG` remains `false`.
Logging is your primary tool in production, as it allows you to record application activity without interrupting the user experience or exposing sensitive information.
- **Log facade**: Use the `Log` facade with various severity levels (`info`, `warning`, `error`, `critical`, etc.) to log messages in your code.
php
```
use Illuminate\Support\Facades\Log;
Log::info('User login successful.', ['user_id' => $user->id]);
Log::error('Payment failed.', ['order_id' => $order->id]);
```
- **Log channels**: Configure different log channels in `config/logging.php` to direct logs to specific destinations, such as daily files, Slack, or external services, making them easier to manage.
- **Contextual information**: Always include contextual data (e.g., user ID, request details) to help pinpoint the source of an error efficiently.
For robust production monitoring, rely on specialized third-party services that provide real-time error tracking and detailed stack traces.
- **Sentry**: This service offers real-time error tracking, performance monitoring, and detailed context (user info, environment, release version) for exceptions. Integrating it via the [Sentry Laravel SDK](https://blog.sentry.io/laravel-debugging-logging-guide/) allows you to be alerted to issues before users report them.
- **Bugsnag or Flare**: Other effective options that integrate well with Laravel and offer similar error monitoring and reporting capabilities.
The `php artisan tinker` command provides an interactive shell to interact with your application's code and data directly from the command line, which is great for testing logic without affecting the live application's front end. You can test Eloquent queries, check configuration values, and more in real-time.
- **`APP_DEBUG` must be `false`**: In your production `.env` file, ensure `APP_DEBUG` is set to `false`. Enabling debug mode in production is a major security risk that can expose sensitive information, such as your application key and database credentials.
- **Avoid `dd()` and `dump()` in production**: The `dd()` (dump and die) function stops the script execution and outputs variable data, which will break your application's functionality for users. These functions are intended for local development only.
- **Review logs regularly**: Access the log files in the `storage/logs` directory to review error logs and other important messages.
- **Use version control**: Ensure any debugging code you add (like `Log::info()` calls) is managed through version control (e.g., Git) and properly removed or conditionalized before deploying to production