Laravel Log Enhancer Package

The Laravel Log Enhancer is a package for Laravel 5.6 adds additional data to your Laravel logs. Thanks to Laravel’s logging updates that ship with Laravel 5.6, this package utilizes the features to extend logging and add data like request headers, memory usage, and session data, among other data.

You configure this package by adding the LogEnhancer to the tap option in your log channel in config/logging.php:

'production_stack' => [
    'driver' => 'stack',
    'tap' => [Freshbitsweb\LaravelLogEnhancer\LogEnhancer::class],
    'channels' => ['daily', 'slack'],
],

After configuring the logging channel, here’s an example log entry with the additional default information:

[2018-03-30 05:07:23] local.INFO: Testing log {"inputs":[],"session":{"_token":"bZXCPViCzmaULIO6GsdLBbveC1yd3BbyH31zfT8c","_previous":{"url":"http://log-enhancer-demo.test"},"_flash":{"old":[],"new":[]}},"url":"/","ip":"127.0.0.1","http_method":"GET","server":"","referrer":null}

Here are the options (also showing you the additional data that’s enabled by default) you can configure for enhanced logging:

<?php

return [
    'log_request_details' => true,
    'log_input_data' => true,
    'log_request_headers' => false,
    'log_session_data' => true,
    'log_memory_usage' => false,
    'log_git_data' => false,
    // You can specify the inputs from the user that should not be logged
    'ignore_input_fields' => ['password', 'confirm_password']
];

Take note of the ignore_input_fields to avoid accidentally logging sensitive user data like passwords or credit cards. Take extra care that private data doesn’t end up in your logs!

To customize the log enhancer, run artisan vendor:publish to interactively install the configuration file or run:

php artisan vendor:publish --tag=laravel-log-enhancer-config

You can install this package with composer by run the following command in a Laravel 5.6 project:

composer require freshbitsweb/laravel-log-enhancer

Thanks to Laravel’s automatic package discovery all you need to do is install the package and optionally configure it for your application.

Read More

Laravel Page Cache for Lightning Fast Page Loads

 

Laravel Page cache is a plugin by Joseph Silber designed to cache HTTP GET responses as static files for lightning fast page loads. This plugin gives you the benefit of a full PHP application, with the benefits of full-page static file caching for all your routes or any specific routes that are static:

While static site builders such as Jekyll and Jigsaw are extremely popular these days, dynamic PHP sites still offer a lot of value even for a site that is mostly static. A proper PHP site allows you to easily add dynamic functionality wherever needed, and also means that there’s no build step involved in pushing updates to the site.

That said, for truly static pages on a site there really is no reason to have to boot up a full PHP app just to serve a static page. Serving a simple HTML page from disk is infinitely faster and less taxing on the server.

To accomplish static file caching, you need to configure your web server to check for the static files the plugin generates. The package readme contains instructions for setting up the necessary URL rewriting for both Apache and Nginx.

Using this Page Cache plugin for full page caching couldn’t be easier. If you want every HTTP GET request in your application to get cached you can add this plugin’s middleware to the web group:

protected $middlewareGroups = [
    'web' => [
        \Silber\PageCache\Middleware\CacheResponse::class,
        /* ... keep the existing middleware here */
    ],
];

You can also define this middleware as an alias and apply it to individual routes or route groups:

protected $routeMiddleware = [
    'page-cache' => Silber\PageCache\Middleware\CacheResponse::class,
    /* ... keep the existing mappings here */
];

Then in an individual route, you can do the following:

Route::middleware('page-cache')->get('/example', 'ExampleController);

Avoiding the need to hit your PHP application means that your web server can serve the fastest response possible when you are serving static content.

Read More

HTTP Cache Packages for Laravel

We wrote about Joseph Silber’s Laravel page cache package, which provides static HTTP response caching for Laravel. There are other open-source packages for caching HTTP responses in Laravel so we thought we’d gather a list of HTTP cache packages you should check out. These packages have unique features that make each of them useful with some functionality overlapping between them, so all of these plugins will be useful depending on your needs.

barryvdh/laravel-httpcache

The barryvdh/laravel-httpcache by Barry vd. Heuvel—initially released in 2013 as a package for Laravel 4.1—is an HTTP cache package for Laravel 5.

This packages uses barryvdh/laravel-stack-middleware to use StackPHP middleware with Laravel 5, allowing your Laravel app to utilize HTTPCache.

Using the package, you can set a TTL or MaxSharedAge in a response:

Route::get('my-page', function(){
   return Response::make('Hello!')->setTtl(60); // Cache 1 minute
});

You can also use the provided middleware:

protected $routeMiddleware = [
    // ...
    'ttl' => \Barryvdh\HttpCache\Middleware\SetTtl::class,
];

Route::get('my-page', function(){
   return 'Hello'
})->middleware('ttl:60'); // Cache 1 minute

Check out the barryvdh/laravel-httpcache GitHub repo for more information.

spatie/laravel-responsecache

Spatie’s laravel-responsecache package speeds up your Laravel app by caching the entire response. I like how this package leverages the existing cache drivers defined in the config/cache.php file (i.e. redis, file, memcached).

You can define a group of routes to be cached for a given time using a middleware:

Route::group(function() {
   Route::get('/another-special-snowflake', 'AnotherSnowflakeController@index');

   Route::get('/yet-another-special-snowflake', 'YetAnotherSnowflakeController@index');
})->middleware('cacheResponse:10');

Another nice feature is that you can programmatically clear the entire cache or specific URIs:

ResponseCache::clear();

// Forget several URIs
ResponseCache::forget(['/some-uri', '/other-uri']);

Or via the command:

php artisan responsecache:clear

The package also allows you to provide a custom caching profile which should implement the provided CacheProfile interface. Defining a custom caching profile gives you granular control on which requests get cached, and for how long.

silber/page-cache

The Laravel Page Cache package by Joseph Silber is another HTTP cache package that is an excellent alternative to static site builders. You can gain the benefit of the performance of a static site, without an extra build step, and without sacrificing the ability for a fully dynamic functionality through PHP.

This package works by using a middleware with your routes and generating static HTML files. Used in tandem with a web server like Nginx, your cached responses won’t touch the application server:

for truly static pages on a site there really is no reason to have to boot up a full PHP app just to serve a static page. Serving a simple HTML page from disk is infinitely faster and less taxing on the server.

The solution? Full page caching.

Using the middleware included in this package, you can selectively cache the response to disk for any given request. Subsequent calls to the same page will be served directly as a static HTML page!

Whether you want to cache all of your routes or a select few that never change, this package offers an excellent way to offload requests from your PHP application and let Nginx serve static files for lightning fast responses.

Read More

Cascading Soft Deletes with Laravel 5

 

Laravel Soft Cascade is a package that makes it easy to perform soft cascade deletes and restores on related models using soft deleting.

Contributor to the package Will Bowman wrote about his package and what happens to the foreign key constraints you want to cascade delete related models, but you have configured soft deletes:

I’ve always used MySQL foreign key constraints to cascade delete related records. Laravel makes it easy to use foreign keys in migrations, set onDelete to cascade and walla, your relations will be deleted automatically.

But what happens when you enable SoftDeletes? Your database is never told to actually ‘delete’ a record, instead the deleted_at field is updated. So what happens to your cascading deletes? Nothing, your related records are left alone.

His post shows an overview of the approach he takes with his package, specifically making it easy to configure cascading deletes without a bunch of boilerplate code:

My solution was to use Events and an array in the Model to tell it what to cascade, this allows us to simply add 2 lines to a Model to enable cascade deleting and restoring:

Using the package, you can enable the SoftCascadeTrait and configure which relationships should soft cascade delete:

use \Askedio\SoftCascade\Traits\SoftCascadeTrait;

protected $softCascade = ['profiles'];

After defining your relations, you can trigger a delete or a restore on your model and related models will be restored or deleted (soft) along with the model:

User::first()->delete();
User::withTrashed()->first()->restore();

Read More

Count Models With the Laravel Visits Package

Laravel Visits is a package by Bader Almutairi for attaching counters to any model to track visits with tags. The main features this package provides, include the following:

• A model item can have many types of recorded visits (using tags).
• It’s not limited to one kind of Model (like some packages that allow only User model).
• Record per visitors and not by visits using IP detecting, so even with refresh visit won’t duplicate (can be changed from config).
• Get Top/Lowest visits per a model.
• Get most visited countries …
• Get visits per a period like a month of a year of an item or model.

Counting Models

The basic usage for counting models includes the following methods for incrementing and decrementing among others:

visits($post)->increment();

// More than one
visits($post)->increment(10);

visits($post)->decrement();

// More than one
visits($post)->decrement(10);

// Only increment once every 30 seconds based on user's IP
visits($post)->seconds(30)->increment()

Getting Data

Once you’ve collected counter data for your model, you can retrieve and filter results with the following:

visits($post)->count();

visits($post)->period('day')->count();

// With the model class
visits('App\Post')->count();

You can also collect other interesting data about country and referrer if you want a quick analytics tool for tracking models:

visits($post)->countries();

// Referrers of visitors
visits($post)->refs();

The geo data for the country functionality is provided through the Torann/laravel-geoip package.

Integration with Eloquent

You can integrate this package directly into your Eloquent model by defining a method like visits:

public function visits()
{
    return visits($this);
}

And then performing calls on the visits object:

$post = Post::find(1);
$post->visits()->increment();
$post->visits()->count();




Read More

Laravel View X-Ray

Laravel View X-Ray is a package for Laravel 5.6 by Marcel Pociot which enables you to peek into your Laravel views and find out which template matches a specific part of the HTML output.

After installing the package it’s enabled by default in development, and then you can hit Cmd + Shift + X (Ctrl + Shift + X on Windows). Note, at the time of writing the View X-Ray package depends on jQuery.

The result is a beautiful visual representation of your view, and it’s easy to understand the view hierarchy at a glance now with X-Ray enabled. You can hide the X-Ray UI by hitting the shortcut again or pressing the esc key.

You can disable X-Ray and exclude views with the following configuration options:

<?php

return [

    /*
     * Determines if the Xray package should be enabled.
     */
    'enabled' => env('XRAY_ENABLED', true),

    /*
     * If you want to exclude certain views from being processed by Xray,
     * you can list them here. Be aware that the check only applies to the
     * root views that you add here. If these views include other views
     * themselves, they need to be excluded manually.
     */
    'excluded' => [
        //
    ],

];

Read More