DEV Community: Ariful Haque Sajib

Choosing the Right Database: 3 Questions to End Your Confusion Forever | By Ariful Haque Sajib

Ariful Haque Sajib — Mon, 02 Mar 2026 16:55:19 +0000

Every developer has been there. You’re starting a new project, the terminal is open, and then the big question hits: “Which database should I use?” 🤔

Should you stick with the reliability of MySQL? Go for the advanced features of PostgreSQL? Or embrace the flexibility of MongoDB?

I used to spend hours overthinking this. But after building various systems, I realized the answer isn’t about which database is “best” — it’s about which one fits your data. You can end the confusion forever by asking yourself these three simple questions.

Question 1: Is Your Data Structured?

If your data can be neatly organized into tables with fixed rows and columns, and if different data points need to talk to each other (Relations, Foreign Keys, Joins), then a Relational Database (RDBMS) is your go-to.

Option A: MySQL

The Vibe: The "Old Reliable" of the web.
Best For: Small to medium-sized projects, CMS (like WordPress), and startups that need to move fast.
Why Choose It? It's incredibly easy to set up, has massive community support, and is highly optimized for read-heavy applications.

Option B: PostgreSQL

The Vibe: The "Powerhouse" for perfectionists.
Best For: Enterprise-level apps, Financial systems (FinTech), and complex data analysis.
Why Choose It? It handles complex queries and advanced indexing like a champ. Its strict adherence to ACID compliance ensures that your data integrity is never compromised, even during complex transactions.

Question 2: Is Your Data Flexible or Semi-Structured?

What if your data doesn't fit into a rigid box? What if every record looks a little different, or the structure changes every week?

The Winner: MongoDB
The Vibe: The "Agile" choice for modern apps.
Best For: Real-time applications, IoT, Content Management, and Social Platforms.
Why Choose It? MongoDB is a NoSQL database that stores data in JSON-like documents. If you need to store nested data or if you're building a prototype where the requirements are constantly evolving, MongoDB's schema-less nature is a lifesaver.

Question 3: How Much Scale Do You Truly Need?

Scaling isn't just a buzzword; it's a technical requirement that dictates your database's future.

Need Simple Vertical Scaling? Both MySQL and PostgreSQL are incredibly capable. With proper indexing and query optimization, they can handle millions of transactions easily.
Need Effortless Horizontal Scaling? If you expect your data to be spread across many servers globally, MongoDB was built for this. Its "sharding" capabilities make horizontal scaling much more intuitive.
Need Strong Consistency? For banking or apps where a single cent cannot go missing, PostgreSQL (or MySQL) is superior due to its strong consistency and complex transaction support

In Short

🏦 Bank / Fintech → PostgreSQL
📝 Blog / CMS → MySQL
📱 Real-time App বা Social Platform → MongoDB

Final Thought
Don't get paralyzed by choice. Most modern databases are powerful enough to handle 90% of use cases. The "best" database is the one that allows you to ship your product and maintain your data's integrity without pulling your hair out.

Threads vs Processes Explained for Beginners with Real-Life Examples | Ariful Haque Sajib

Ariful Haque Sajib — Mon, 23 Jun 2025 17:05:03 +0000

1. What is a Thread?
Definition:
A thread is a line of execution. A running program can have one or more threads that perform tasks.

Simple Example:
You’re listening to music on your computer (one thread) while reading something in your browser (another thread). Both are happening at the same time.

2. What is a Process?
Definition:
A process is an instance of a running program. When you run an app, it becomes a process.

Simple Example:
Opening the calculator is one process. Opening Notepad is another.

3. What is a Single-Threaded Process?
Definition:
A program where only one thread runs is called a single-threaded process.

Simple Example:
One person doing only one task at a time, like only cooking.

4. What is a Multi-Threaded Process?
Definition:
A program where multiple threads run simultaneously is called a multi-threaded process.

Simple Example:
One person cooking, listening to the radio, and talking on the phone — doing three tasks at once.

5. What is a Main Thread?
Definition:
The first thread that starts when a program runs is the main thread.

Simple Example:
A manager starts a task and then assigns parts to others — he is the main thread.

6. What is Thread Safety?
Definition:
If multiple threads can access or modify data without causing problems, it’s called thread-safe.

Simple Example:
Several people writing in a diary one by one — no conflicts occur.

7. What is a Race Condition?
Definition:
When multiple threads try to change the same data at the same time, causing unexpected results.

Simple Example:
Two people trying to write with the same pen at once — the writing gets messy.

8. What is a Deadlock?
Definition:
When two threads wait on each other’s resources and neither can continue, it’s a deadlock.

Simple Example:
Two people need each other’s keys but won’t give them up — both get stuck.

9. What is Concurrency?
Definition:
When multiple tasks start and progress alternately, that’s concurrency.

Simple Example:
You cook and also make tea, switching between the two.

10. What is Parallelism?
Definition:
When multiple tasks run exactly at the same time, it’s parallelism.

Simple Example:
One person is cooking while another is making tea — both tasks at once.

11. What is a Thread Pool?
Definition:
A collection of pre-created threads that can be reused instead of creating new ones each time.

Simple Example:
A restaurant has waiters on standby — ready when an order comes.

12. What is Context Switching?
Definition:
Switching from one thread to another by saving the current state and loading another’s state.

Simple Example:
You’re reading a book, get a phone call, talk, and then return to reading. That switch is context switching.

১. থ্রেড (Thread)
সংজ্ঞা:
থ্রেড হলো একটি কাজ চালানোর লাইন। কোনো প্রোগ্রাম চালু হলে সেই প্রোগ্রামে এক বা একাধিক থ্রেড থাকতে পারে যা কাজগুলো চালিয়ে নিয়ে যায়।

সহজ উদাহরণ:
আপনি কম্পিউটারে গান শুনছেন (একটা থ্রেড), একই সাথে ব্রাউজারে কিছু পড়ছেন (আরেকটা থ্রেড)। দুটো কাজ একসাথে হচ্ছে।

২. প্রসেস (Process)
সংজ্ঞা:
প্রসেস হলো একটি চালু প্রোগ্রাম। যখন আপনি কোনো অ্যাপ চালান, তখন সেটি একটি প্রসেস হিসেবে কাজ করে।

সহজ উদাহরণ:
আপনি যখন ক্যালকুলেটর ওপেন করেন, তখন সেটি একটি প্রসেস। আর যখন নোটপ্যাড চালান, সেটিও আরেকটি প্রসেস।

৩. সিঙ্গেল থ্রেডেড প্রসেস
সংজ্ঞা:
যে প্রোগ্রামে শুধু একটি থ্রেড কাজ করে তাকে সিঙ্গেল থ্রেডেড প্রসেস বলে।

সহজ উদাহরণ:
একজন মানুষ এক সময়ে একটি কাজ করছে — যেমন শুধু রান্না করছে, অন্য কিছু না।

৪. মাল্টিথ্রেডেড প্রসেস
সংজ্ঞা:
যে প্রোগ্রামে একাধিক থ্রেড একসাথে কাজ করে তাকে মাল্টিথ্রেডেড প্রসেস বলে।

সহজ উদাহরণ:
একজন মানুষ একই সময়ে রান্না করছে, রেডিও শুনছে, আর ফোনে কথা বলছে — তিনটা কাজ একসাথে করছে।

৫. মেইন থ্রেড (Main Thread)
সংজ্ঞা:
প্রোগ্রাম চালু হলে প্রথম যে থ্রেড শুরু হয়, তাকে মেইন থ্রেড বলে।

সহজ উদাহরণ:
কোনো কাজের শুরুতে একজন ম্যানেজার আসেন (মেইন থ্রেড), পরে তিনি অন্যদের (নতুন থ্রেড) ডেকে কাজ ভাগ করে দেন।

৬. থ্রেড সেফটি (Thread Safety)
সংজ্ঞা:
যদি একাধিক থ্রেড একসাথে কোনো ডাটা বা ফাংশনে কাজ করেও কোনো সমস্যা না হয়, তবে সেটিকে থ্রেড-সেফ বলা হয়।

সহজ উদাহরণ:
একটি ডায়েরিতে একাধিক মানুষ লিখছে, কিন্তু সবাই সময় নিয়ে লিখছে, তাই কিছু গণ্ডগোল হচ্ছে না।

৭. রেস কন্ডিশন (Race Condition)
সংজ্ঞা:
যখন একাধিক থ্রেড একই সময়ে একটি ডাটা পরিবর্তন করার চেষ্টা করে এবং এতে ভুল হয়, তখন সেটি রেস কন্ডিশন।

সহজ উদাহরণ:
দুজন একসাথে একই কলম দিয়ে লিখতে চাইলে লেখা বিগড়ে যায়।

৮. ডেডলক (Deadlock)
সংজ্ঞা:
যখন দুটি থ্রেড একে অপরের রিসোর্সের জন্য অপেক্ষা করে এবং কেউই কাজ করতে পারে না, তখন ডেডলক হয়।

সহজ উদাহরণ:
দুজন মানুষ একে অপরের কাছে চাবি চায়, কিন্তু কেউই ছাড়তে রাজি নয় — তাই দুজনেই আটকে যায়।

৯. কনকারেন্সি (Concurrency)
সংজ্ঞা:
যখন একাধিক কাজ একসাথে শুরু হয় এবং একটার পর একটা করে চলে, তখন তাকে কনকারেন্সি বলে।

সহজ উদাহরণ:
আপনি রান্না করছেন, মাঝে মাঝে চা বানাচ্ছেন — দুটো কাজই চলছে একসাথে, একটু একটু করে।

১০. প্যারালেলিজম (Parallelism)
সংজ্ঞা:
যখন একাধিক কাজ একই সময়ে একসাথে চলে, তখন তাকে প্যারালেলিজম বলে।

সহজ উদাহরণ:
একজন রান্না করছে, আরেকজন চা বানাচ্ছে — দুজন দুইটা কাজ করছে একসাথে।

১১. থ্রেড পুল (Thread Pool)
সংজ্ঞা:
একগুচ্ছ থ্রেড তৈরি করে রাখা হয় যাতে প্রয়োজনে সেগুলো ব্যবহার করা যায়, একবার একবার নতুন থ্রেড না বানাতে হয়।

সহজ উদাহরণ:
রেস্টুরেন্টে কিছু ওয়েটার standby থাকে, অর্ডার এলেই তাদের কাজে লাগানো হয়।

১২. কনটেক্সট সুইচিং (Context Switching)
সংজ্ঞা:
এক থ্রেড থেকে অন্য থ্রেডে যাওয়ার জন্য বর্তমান অবস্থা সংরক্ষণ করে নতুন থ্রেড চালু করাকে কনটেক্সট সুইচিং বলে।

সহজ উদাহরণ:
আপনি বই পড়ছিলেন, হঠাৎ ফোন এল — আপনি পড়া বন্ধ করে ফোনে কথা বললেন। পরে আবার পড়া শুরু করলেন। এই পরিবর্তনটাই কনটেক্সট সুইচিং।

I’m Md Ariful Haque Sajib, a Software Engineer, specializing in PHP, Laravel, Spring Boot, Vue.js, and React.js. With expertise in E-commerce, Payment Gateways, APIs, various Management and Finance-based software. I am passionate about 🧠 learning and delivering 🌟 high-quality solutions.

📌 Follow me for updates and insights:
🌐 GitHub: ArifulHaque313
🔗 LinkedIn: Md Ariful Haque Sajib

📧 Contact: asajib7654@gmail.com

📢 Hashtags:

Thread #MultiThreading #SingleThread #concurrency #DeadLock

ArifulHaqueSajib #arifulhaque313 #sajib

Hope this makes it more visually appealing! 😊

What is Git Stash ? A Complete Guide by Ariful Haque Sajib

Ariful Haque Sajib — Sun, 22 Jun 2025 12:56:36 +0000

Learn how to use Git Stash to save uncommitted changes, switch branches, and restore work efficiently. Essential commands & best practices explained.

Have you ever been in the middle of coding, needed to switch branches, but didn’t want to commit half-finished work? Git Stash is the solution!

This guide will explain:
✅ What Git Stash is and when to use it
✅ Essential Git Stash commands with examples
✅ Best practices and common pitfalls

What is Git Stash?
Git Stash temporarily saves your uncommitted changes (modified, staged, or untracked files) so you can switch branches, pull updates, or work on something else without losing progress.

When Should You Use Git Stash?
✔ Switching branches with uncommitted changes
✔ Saving work before pulling remote updates
✔ Temporarily storing experimental code
✔ Avoiding unnecessary “WIP” (Work in Progress) commits

Essential Git Stash Commands

1. Stash Your Changes
Save all modified and staged files (but not untracked files):

git stash

Save including untracked files:

git stash -u

Save with a custom message for easy identification:

git stash save "Feature X - WIP"

2. List All Stashes
View your stash history:

git stash list

Example output:

stash@{0}: On main: Feature X - WIP  
stash@{1}: On dev: Bugfix Y - partial

3. Apply (Restore) a Stash
Restore the latest stash (keeps it in the stash list):

git stash apply

Restore a specific stash (e.g., stash@{1}):

git stash apply stash@{1}

4. Pop a Stash (Apply & Delete)
Restore the latest stash and remove it from the stash list:

git stash pop

Delete a Stash Remove a specific stash:

git stash drop stash@{1}

Clear all stashes:

git stash clear

Create a Branch from a Stash If your stash conflicts with current changes, create a new branch:

git stash branch new-branch-name stash@{1}

Conclusion
Git Stash is a powerful tool for managing unfinished work without cluttering your commit history. Whether you’re switching tasks, pulling updates, or experimenting, stash helps keep your workflow clean.

📌 Follow me for updates and insights:
🌐 GitHub: ArifulHaque313
🔗 LinkedIn: Md Ariful Haque Sajib

📧 Contact: asajib7654@gmail.com

📢 Hashtags:

GitStash #Git #Github

ArifulHaqueSajib #arifulhaque313 #sajib

Hope this makes it more visually appealing! 😊

What is git tags ? How to Use Git Tags (Create, List, Push & Delete) — Ariful Haque Sajib

Ariful Haque Sajib — Sat, 21 Jun 2025 11:47:30 +0000

Learn Git tagging essentials with this step-by-step guide by Ariful Haque Sajib. Understand what Git tags are, why they’re useful, the types of tags (lightweight & annotated), and how to create, list, delete, and push tags efficiently. Perfect for developers mastering Git version control!

Git tags are a powerful feature that allow you to mark specific points in your repository’s history as important, typically used for release points (v1.0, v2.0, etc.). Here’s everything you need to know about Git tags.

What are Git Tags?
Tags are references to specific points in Git history. Unlike branches, tags are immutable — once created, they don’t move as you add new commits. They’re commonly used to:

Mark release versions (v1.0.0, v2.1.3)
Create stable points to refer back to
Provide meaningful names to specific commits

Types of Tags
There are two types of Git tags:

Lightweight tags: Just a pointer to a specific commit
Annotated tags: Store additional metadata (tagger name, email, date, message)

Why Use Tags?
Version control: Clearly mark release versions
Documentation: Annotated tags can include release notes
Deployment: Easily deploy specific versions
Reference: Quickly checkout important points in history

Useful Git Tag Commands

Creating Tags

# Create a lightweight tag
git tag v1.0.0

# Create an annotated tag (recommended for releases)
git tag -a v1.0.0 -m "Version 1.0.0 release"

# Tag a specific commit
git tag -a v1.0.0 abc1234 -m "Version 1.0.0"

Listing Tags

# List all tags
git tag

# List tags with pattern matching
git tag -l "v1.*"

# Show tag details
git show v1.0.0

Pushing Tags

# Push a specific tag to remote
git push origin v1.0.0

# Push all tags to remote
git push origin --tags

Checking out Tags

# Checkout a tag (creates detached HEAD state)
git checkout v1.0.0

# Create a branch from a tag
git checkout -b version1 v1.0.0

Deleting Tags

# Delete local tag
git tag -d v1.0.0

# Delete remote tag
git push origin --delete v1.0.0

Advanced Usage

# Sign a tag with GPG
git tag -s v1.0.0 -m "Signed version 1.0.0"

# Verify a signed tag
git tag -v v1.0.0

# List tags with creation dates
git for-each-ref --sort=-taggerdate --format '%(refname:short) %(taggerdate:short)' refs/tag

Git Tag vs Branch: Key Differences
Understanding the distinction between tags and branches is essential for effective Git workflow management. Here’s a detailed comparison:

*Example: *

Conclusion
Git tags are powerful tools for marking important points in your project’s history. Use annotated tags for releases, follow consistent naming conventions, and integrate them into your development workflow. They provide clear reference points for versions, enable easy rollbacks, and improve team collaboration around releases.

Remember: Tags are immutable references that help organize your project’s timeline and facilitate better version management.

I’m Md Ariful Haque Sajib, a Software Engineer 👨‍💻 at Adventure Dhaka Limited, specializing in PHP, Laravel, Spring Boot, Vue.js, and React.js. With expertise in E-commerce, Payment Gateways, APIs, various Management and Finance-based software. I am passionate about 🧠 learning and delivering 🌟 high-quality solutions.

📌 Follow me for updates and insights:
🌐 GitHub: ArifulHaque313
🔗 LinkedIn: Md Ariful Haque Sajib

📧 Contact: asajib7654@gmail.com

📢 Hashtags:

GitTags #Release

ArifulHaqueSajib #arifulhaque313 #sajib

Hope this makes it more visually appealing! 😊

Laravel Logging By Ariful Haque Sajib

Ariful Haque Sajib — Sun, 25 May 2025 13:04:18 +0000

Learn how to use Laravel logging with Monolog, configure channels (files, Slack, etc.), and use logs for debugging. Step-by-step guide by Ariful Haque Sajib for beginners and advanced developers

Understanding Laravel's Logging System

Laravel's logging system is built on top of Monolog, a powerful logging library for PHP. This integration provides a robust foundation with multiple "channels" for directing log messages to different outputs like files, the system error log, or even external services.

Log Levels

Laravel supports eight log levels, arranged from highest to lowest severity:

Emergency — System is unusable
Alert — Action must be taken immediately
Critical — Critical conditions
Error — Error conditions
Warning — Warning conditions
Notice — Normal but significant events
Info — Informational messages
Debug — Detailed debug information

These levels help categorize log messages based on their importance, making it easier to filter and respond to issues appropriately.

Basic Logging in Laravel

Writing Log Messages
Laravel makes it simple to write log messages. Here’s how to use the most common logging methods:

// Using the Log facade
use Illuminate\Support\Facades\Log;

// Basic info log
Log::info('User logged in successfully');

// Log with context data
Log::info('User profile updated', ['user_id' => 123, 'changes' => ['name', 'email']]);

// Different log levels
Log::emergency('System down');
Log::alert('Database connection failed');
Log::critical('Payment system not responding');
Log::error('Unable to process order #123');
Log::warning('User quota nearly reached');
Log::notice('Scheduled maintenance starting');
Log::info('New user registered');
Log::debug('Query executed in 15ms')

You can also use the global logger() helper function:

// Simple log message
logger('User logged in successfully');

// With context data
logger('Order processed', ['order_id' => 456, 'amount' => 99.99]);

Viewing Logs
By default, Laravel writes logs to files stored in the storage/logs directory. The default log file is named laravel.log, but this can be configured as we'll see later.

Configuring Laravel Logging

The Configuration File
Laravel's logging configuration is located in the config/logging.php file. This file defines the available logging channels and their configurations.

The key settings in this file include:

default - The default channel used when writing log messages
channels - An array of available logging channels
deprecations - Configuration for logging deprecated code usage

Available Channel Drivers
Laravel supports multiple log channel drivers out of the box:

stack - A wrapper for multiple channels
single - Single file logger
daily - Rotates log files daily
slack - Sends logs to Slack
papertrail - Sends logs to Papertrail
syslog - Writes to the system log
errorlog - Writes to the PHP error_log
monolog - Custom Monolog handler
custom - Custom logger using factory

Common Configuration Examples
Single File Logging

'single' => [
    'driver' => 'single',
    'path' => storage_path('logs/laravel.log'),
    'level' => env('LOG_LEVEL', 'debug'),
],

Daily Log Files with Retention

'daily' => [
    'driver' => 'daily',
    'path' => storage_path('logs/laravel.log'),
    'level' => env('LOG_LEVEL', 'debug'),
    'days' => 14, // Keep logs for 14 days
],

Stack Channel (Multiple Destinations)

'stack' => [
    'driver' => 'stack',
    'channels' => ['single', 'slack'],
    'ignore_exceptions' => false,
],

Slack Notifications for Errors

'slack' => [
    'driver' => 'slack',
    'url' => env('LOG_SLACK_WEBHOOK_URL'),
    'username' => 'Laravel Log',
    'emoji' => ':boom:',
    'level' => env('LOG_LEVEL', 'critical'),
],

Advanced Logging Techniques

Creating Custom Channels
You can create custom logging channels by extending the logging configuration:

// In config/logging.php
'channels' => [
    // ... other channels

    'important' => [
        'driver' => 'single',
        'path' => storage_path('logs/important.log'),
        'level' => 'notice',
    ],
],

Then use it by specifying the channel:

Log::channel('important')->info('This goes to the important log');

Using Channel Stacks
Channel stacks allow you to broadcast log messages to multiple channels:

// In config/logging.php
'critical_logs' => [
    'driver' => 'stack',
    'channels' => ['single', 'slack', 'syslog'],
],

Then use it like:

Log::stack(['critical_logs'])->critical('Major system failure detected');

Contextual Information
Adding context to log messages makes debugging easier:

Log::info('Order processed', [
    'order_id' => $order->id,
    'customer' => $customer->email,
    'amount' => $order->total,
    'items' => $order->items->count()
]);

Customizing Monolog
For advanced customization, you can tap into the Monolog instance:

'customized' => [
    'driver' => 'single',
    'path' => storage_path('logs/custom.log'),
    'level' => 'debug',
    'tap' => [App\Logging\CustomizeFormatter::class],
],

Then create the handler:

namespace App\Logging;

use Monolog\Formatter\LineFormatter;

class CustomizeFormatter
{
    public function __invoke($logger)
    {
        foreach ($logger->getHandlers() as $handler) {
            $handler->setFormatter(new LineFormatter(
                '[%datetime%] %channel%.%level_name%: %message% %context% %extra%'
            ));
        }
    }
}

Best Practices for Laravel Logging

1. Use Appropriate Log Levels
Match the log level to the significance of the event:

Use debug for detailed development information
Use info for general operational events
Use notice for significant but normal events
Use warning for non-critical issues that need attention
Use error and above for failures that need immediate response

2. Include Contextual Data
Always add relevant context to log messages:

// Bad: Generic message with no context
Log::error('Database error');

// Good: Specific message with context
Log::error('Database query failed', [
    'query' => $query,
    'error' => $exception->getMessage(),
    'user_id' => auth()->id()
]);

3. Configure Log Rotation
For production applications, configure log rotation to manage disk space:

'daily' => [
    'driver' => 'daily',
    'path' => storage_path('logs/laravel.log'),
    'level' => 'debug',
    'days' => 7, // Adjust based on your needs
],

4. Use Structured Logging
When possible, log structured data that's easy to parse and analyze:

Log::info('API Request', [
    'endpoint' => '/api/users',
    'method' => 'POST',
    'response_code' => 200,
    'response_time' => 45.2, // milliseconds
    'user_agent' => $request->userAgent()
]);

5. Set Up Real-time Alerts
For critical issues, configure channels that notify the team immediately:

'slack' => [
    'driver' => 'slack',
    'url' => env('LOG_SLACK_WEBHOOK_URL'),
    'username' => 'Laravel Error Bot',
    'emoji' => ':rotating_light:',
    'level' => 'error', // Only errors and above
],

Common Logging Scenarios

Exception Logging
Laravel automatically logs unhandled exceptions, but you can manually log exceptions too:

try {
    // Some risky operation
} catch (\Exception $e) {
    Log::error('Failed to process payment', [
        'exception' => $e->getMessage(),
        'order_id' => $order->id
    ]);

    // Handle the exception
}

User Activity Logging
Track important user actions:

Log::info('User updated profile', [
    'user_id' => $user->id,
    'changed_fields' => $changedFields
]);

Performance Logging
Monitor application performance:

$startTime = microtime(true);

// Perform operation

$executionTime = microtime(true) - $startTime;
Log::debug('Query execution time', [
    'query' => $queryString,
    'execution_time' => $executionTime,
    'rows_returned' => $results->count()
]);

API Interaction Logging
Log API requests and responses:

Log::info('External API call', [
    'endpoint' => $url,
    'method' => 'POST',
    'request_data' => $requestData,
    'response_code' => $response->status(),
    'response_time' => $responseTime
]);

Debugging with Logs
Using Log Messages for Debugging
When debugging complex issues, strategic log messages can help:

Log::debug('Starting import process');

foreach ($records as $index => $record) {
    Log::debug("Processing record {$index}", ['data' => $record]);

    // Process record

    Log::debug("Completed record {$index}");
}

Log::debug('Import process completed', ['total_records' => count($records)]);

Temporary Debug Logging
For temporary debugging, you can use the tap helper to log without changing your code flow:

return tap($result, function ($value) {
    Log::debug('Query result', ['value' => $value]);
});

Logging for Different Environments

Development Environment
In development, you typically want verbose logging:

// .env for development
LOG_CHANNEL=stack
LOG_LEVEL=debug

Production Environment
In production, focus on important events and manage log size:

// .env for production
LOG_CHANNEL=daily
LOG_LEVEL=warning  # Only logs warning and above

Laravel Logging Demo Project

This project demonstrates various Laravel logging features including:

Different log levels
Multiple logging channels
Custom formatters
Contextual logging
Exception logging
Performance monitoring

<?php


// ===================================
// 1. CONFIGURATION FILES
// ===================================

// config/logging.php
return [
    'default' => env('LOG_CHANNEL', 'stack'),

    'deprecations' => env('LOG_DEPRECATIONS_CHANNEL', 'null'),

    'channels' => [
        'stack' => [
            'driver' => 'stack',
            'channels' => ['single'],
            'ignore_exceptions' => false,
        ],

        'single' => [
            'driver' => 'single',
            'path' => storage_path('logs/laravel.log'),
            'level' => env('LOG_LEVEL', 'debug'),
        ],

        'daily' => [
            'driver' => 'daily',
            'path' => storage_path('logs/laravel.log'),
            'level' => env('LOG_LEVEL', 'debug'),
            'days' => 14,
        ],

        // Custom channels for our demo
        'user_activity' => [
            'driver' => 'single',
            'path' => storage_path('logs/user-activity.log'),
            'level' => 'info',
        ],

        'api_requests' => [
            'driver' => 'daily',
            'path' => storage_path('logs/api-requests.log'),
            'level' => 'debug',
            'days' => 7,
        ],

        'performance' => [
            'driver' => 'single',
            'path' => storage_path('logs/performance.log'),
            'level' => 'debug',
            'tap' => [App\Logging\PerformanceFormatter::class],
        ],

        'errors' => [
            'driver' => 'daily',
            'path' => storage_path('logs/errors.log'),
            'level' => 'error',
            'days' => 30,
        ],

        'security' => [
            'driver' => 'single',
            'path' => storage_path('logs/security.log'),
            'level' => 'warning',
        ],

        // Example Slack channel (requires webhook URL)
        'slack' => [
            'driver' => 'slack',
            'url' => env('LOG_SLACK_WEBHOOK_URL'),
            'username' => 'Laravel Logger',
            'emoji' => ':boom:',
            'level' => env('LOG_LEVEL', 'critical'),
        ],

        'critical_stack' => [
            'driver' => 'stack',
            'channels' => ['errors', 'slack'],
        ],
    ],
];

// ===================================
// 2. CUSTOM FORMATTER
// ===================================

// app/Logging/PerformanceFormatter.php
namespace App\Logging;

use Monolog\Formatter\LineFormatter;

class PerformanceFormatter
{
    public function __invoke($logger)
    {
        foreach ($logger->getHandlers() as $handler) {
            $handler->setFormatter(new LineFormatter(
                "[%datetime%] PERFORMANCE: %message% | Duration: %context.duration%ms | Memory: %context.memory_usage%MB\n"
            ));
        }
    }
}

// ===================================
// 3. LOGGING SERVICE CLASS
// ===================================

// app/Services/LoggingService.php
namespace App\Services;

use Illuminate\Support\Facades\Log;
use Illuminate\Http\Request;

class LoggingService
{
    /**
     * Log user activity with context
     */
    public function logUserActivity(string $action, array $context = []): void
    {
        Log::channel('user_activity')->info($action, array_merge([
            'user_id' => auth()->id() ?? 'guest',
            'ip_address' => request()->ip(),
            'user_agent' => request()->userAgent(),
            'timestamp' => now()->toISOString(),
        ], $context));
    }

    /**
     * Log API request with performance metrics
     */
    public function logApiRequest(Request $request, $response, float $duration): void
    {
        Log::channel('api_requests')->info('API Request', [
            'method' => $request->method(),
            'url' => $request->fullUrl(),
            'ip' => $request->ip(),
            'user_agent' => $request->userAgent(),
            'status_code' => $response->getStatusCode(),
            'duration_ms' => round($duration * 1000, 2),
            'memory_usage' => round(memory_get_peak_usage(true) / 1024 / 1024, 2),
            'timestamp' => now()->toISOString(),
        ]);
    }

    /**
     * Log performance metrics
     */
    public function logPerformance(string $operation, float $duration, array $context = []): void
    {
        Log::channel('performance')->debug($operation, array_merge([
            'duration' => round($duration * 1000, 2), // Convert to milliseconds
            'memory_usage' => round(memory_get_peak_usage(true) / 1024 / 1024, 2), // Convert to MB
            'timestamp' => now()->toISOString(),
        ], $context));
    }

    /**
     * Log security events
     */
    public function logSecurityEvent(string $event, string $level = 'warning', array $context = []): void
    {
        Log::channel('security')->{$level}($event, array_merge([
            'ip_address' => request()->ip(),
            'user_agent' => request()->userAgent(),
            'user_id' => auth()->id() ?? 'anonymous',
            'timestamp' => now()->toISOString(),
        ], $context));
    }

    /**
     * Log exceptions with full context
     */
    public function logException(\Throwable $exception, array $context = []): void
    {
        Log::channel('errors')->error('Exception occurred', array_merge([
            'exception_class' => get_class($exception),
            'message' => $exception->getMessage(),
            'file' => $exception->getFile(),
            'line' => $exception->getLine(),
            'trace' => $exception->getTraceAsString(),
            'user_id' => auth()->id() ?? 'guest',
            'url' => request()->fullUrl(),
            'timestamp' => now()->toISOString(),
        ], $context));
    }
}

// ===================================
// 4.CONTROLLER
// ===================================

// app/Http/Controllers/LoggingDemoController.php
namespace App\Http\Controllers;

use App\Services\LoggingService;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\DB;

class LoggingDemoController extends Controller
{
    protected LoggingService $loggingService;

    public function __construct(LoggingService $loggingService)
    {
        $this->loggingService = $loggingService;
    }

    /**
     * Demonstrate all log levels
     */
    public function demonstrateLogLevels()
    {
        Log::emergency('System is completely down - EMERGENCY');
        Log::alert('Database connection lost - immediate action required');
        Log::critical('Payment gateway not responding - CRITICAL');
        Log::error('Failed to process user registration');
        Log::warning('User storage quota at 90%');
        Log::notice('Scheduled maintenance completed successfully');
        Log::info('New user registered: john@example.com');
        Log::debug('Query executed successfully in 45ms');

        return response()->json([
            'message' => 'All log levels demonstrated. Check your log files!',
            'log_files' => [
                'main' => storage_path('logs/laravel.log'),
                'errors' => storage_path('logs/errors.log'),
            ]
        ]);
    }

    /**
     * Demonstrate contextual logging
     */
    public function demonstrateContextualLogging()
    {
        // User activity logging
        $this->loggingService->logUserActivity('Profile Updated', [
            'changed_fields' => ['name', 'email'],
            'old_email' => 'old@example.com',
            'new_email' => 'new@example.com'
        ]);

        // API request simulation
        $startTime = microtime(true);
        sleep(1); // Simulate processing time
        $duration = microtime(true) - $startTime;

        $this->loggingService->logApiRequest(
            request(),
            response()->json(['status' => 'success']),
            $duration
        );

        return response()->json([
            'message' => 'Contextual logging demonstrated',
            'check_files' => [
                'user_activity' => storage_path('logs/user-activity.log'),
                'api_requests' => storage_path('logs/api-requests.log'),
            ]
        ]);
    }

    /**
     * Demonstrate performance logging
     */
    public function demonstratePerformanceLogging()
    {
        // Database query performance
        $startTime = microtime(true);

        // Simulate database operation
        DB::select('SELECT SLEEP(0.5)'); // Simulate slow query

        $duration = microtime(true) - $startTime;

        $this->loggingService->logPerformance('Database Query', $duration, [
            'query' => 'SELECT * FROM users WHERE active = 1',
            'rows_affected' => 150,
            'slow_query' => $duration > 0.1 ? 'yes' : 'no'
        ]);

        // File processing performance
        $startTime = microtime(true);

        // Simulate file processing
        for ($i = 0; $i < 10000; $i++) {
            // Simulate processing
        }

        $duration = microtime(true) - $startTime;

        $this->loggingService->logPerformance('File Processing', $duration, [
            'files_processed' => 10000,
            'batch_size' => 1000
        ]);

        return response()->json([
            'message' => 'Performance logging demonstrated',
            'check_file' => storage_path('logs/performance.log')
        ]);
    }

    /**
     * Demonstrate exception logging
     */
    public function demonstrateExceptionLogging()
    {
        try {
            // Simulate various types of exceptions
            throw new \InvalidArgumentException('Invalid user data provided');
        } catch (\Exception $e) {
            $this->loggingService->logException($e, [
                'user_input' => ['name' => '', 'email' => 'invalid-email'],
                'validation_errors' => ['name' => 'required', 'email' => 'invalid format']
            ]);
        }

        try {
            // Simulate database exception
            throw new \PDOException('Connection to database failed');
        } catch (\Exception $e) {
            $this->loggingService->logException($e, [
                'database_host' => 'localhost',
                'retry_attempts' => 3
            ]);
        }

        return response()->json([
            'message' => 'Exception logging demonstrated',
            'check_file' => storage_path('logs/errors.log')
        ]);
    }

    /**
     * Demonstrate security logging
     */
    public function demonstrateSecurityLogging()
    {
        // Failed login attempt
        $this->loggingService->logSecurityEvent('Failed Login Attempt', 'warning', [
            'attempted_email' => 'admin@example.com',
            'failed_attempts_count' => 3,
            'locked_out' => false
        ]);

        // Suspicious activity
        $this->loggingService->logSecurityEvent('Suspicious Activity Detected', 'alert', [
            'activity_type' => 'Multiple rapid requests',
            'request_count' => 100,
            'time_window' => '1 minute',
            'blocked' => true
        ]);

        // Password change
        $this->loggingService->logSecurityEvent('Password Changed', 'notice', [
            'user_email' => 'user@example.com',
            'password_strength' => 'strong'
        ]);

        return response()->json([
            'message' => 'Security logging demonstrated',
            'check_file' => storage_path('logs/security.log')
        ]);
    }

    /**
     * Demonstrate channel-specific logging
     */
    public function demonstrateChannelLogging()
    {
        // Log to specific channels
        Log::channel('user_activity')->info('User logged in', ['user_id' => 123]);
        Log::channel('api_requests')->debug('API call made', ['endpoint' => '/api/users']);
        Log::channel('errors')->error('Payment processing failed', ['order_id' => 456]);
        Log::channel('security')->warning('Brute force attempt detected');

        // Log to multiple channels using stack
        Log::stack(['errors', 'slack'])->critical('System critical error detected');

        return response()->json([
            'message' => 'Channel-specific logging demonstrated',
            'channels_used' => ['user_activity', 'api_requests', 'errors', 'security', 'critical_stack']
        ]);
    }

    /**
     * Demonstrate structured logging for analytics
     */
    public function demonstrateStructuredLogging()
    {
        // E-commerce events
        Log::info('Product Purchased', [
            'event_type' => 'purchase',
            'product_id' => 'prod_123',
            'product_name' => 'Laravel Course',
            'price' => 99.99,
            'currency' => 'USD',
            'customer_id' => 'cust_456',
            'payment_method' => 'credit_card',
            'discount_applied' => 10.00,
            'final_amount' => 89.99,
            'timestamp' => now()->toISOString()
        ]);

        // User behavior tracking
        Log::info('Page View', [
            'event_type' => 'page_view',
            'page_url' => '/products/laravel-course',
            'referrer' => 'https://google.com',
            'session_id' => 'sess_789',
            'user_id' => auth()->id() ?? null,
            'device_type' => 'desktop',
            'browser' => 'Chrome',
            'country' => 'US',
            'timestamp' => now()->toISOString()
        ]);

        return response()->json([
            'message' => 'Structured logging for analytics demonstrated',
            'note' => 'Check logs for structured data that can be easily parsed for analytics'
        ]);
    }
}

// ===================================
// 5. MIDDLEWARE FOR AUTOMATIC LOGGING
// ===================================

// app/Http/Middleware/LogRequests.php
namespace App\Http\Middleware;

use App\Services\LoggingService;
use Closure;
use Illuminate\Http\Request;

class LogRequests
{
    protected LoggingService $loggingService;

    public function __construct(LoggingService $loggingService)
    {
        $this->loggingService = $loggingService;
    }

    public function handle(Request $request, Closure $next)
    {
        $startTime = microtime(true);

        $response = $next($request);

        $duration = microtime(true) - $startTime;

        // Log API requests automatically
        if ($request->is('api/*')) {
            $this->loggingService->logApiRequest($request, $response, $duration);
        }

        return $response;
    }
}

// ===================================
// 6. ARTISAN COMMAND FOR LOG ANALYSIS
// ===================================

// app/Console/Commands/AnalyzeLogs.php
namespace App\Console\Commands;

use Illuminate\Console\Command;

class AnalyzeLogs extends Command
{
    protected $signature = 'logs:analyze {--file=laravel.log}';
    protected $description = 'Analyze log files and provide statistics';

    public function handle()
    {
        $filename = $this->option('file');
        $filepath = storage_path("logs/{$filename}");

        if (!file_exists($filepath)) {
            $this->error("Log file {$filename} not found!");
            return 1;
        }

        $content = file_get_contents($filepath);
        $lines = explode("\n", $content);

        $stats = [
            'total_lines' => count($lines),
            'emergency' => substr_count($content, '.EMERGENCY:'),
            'alert' => substr_count($content, '.ALERT:'),
            'critical' => substr_count($content, '.CRITICAL:'),
            'error' => substr_count($content, '.ERROR:'),
            'warning' => substr_count($content, '.WARNING:'),
            'notice' => substr_count($content, '.NOTICE:'),
            'info' => substr_count($content, '.INFO:'),
            'debug' => substr_count($content, '.DEBUG:'),
        ];

        $this->info("Log Analysis for {$filename}");
        $this->line("=====================================");
        $this->line("Total Lines: {$stats['total_lines']}");
        $this->line("");
        $this->line("Log Level Distribution:");
        foreach (['emergency', 'alert', 'critical', 'error', 'warning', 'notice', 'info', 'debug'] as $level) {
            $count = $stats[$level];
            $percentage = $stats['total_lines'] > 0 ? round(($count / $stats['total_lines']) * 100, 2) : 0;
            $this->line(sprintf("%-10s: %5d (%5.2f%%)", ucfirst($level), $count, $percentage));
        }

        return 0;
    }
}

// ===================================
// 7. ROUTES
// ===================================

// routes/web.php
use App\Http\Controllers\LoggingDemoController;

Route::prefix('logging-demo')->group(function () {
    Route::get('/', function () {
        return view('logging-demo');
    });

    Route::get('/levels', [LoggingDemoController::class, 'demonstrateLogLevels']);
    Route::get('/contextual', [LoggingDemoController::class, 'demonstrateContextualLogging']);
    Route::get('/performance', [LoggingDemoController::class, 'demonstratePerformanceLogging']);
    Route::get('/exceptions', [LoggingDemoController::class, 'demonstrateExceptionLogging']);
    Route::get('/security', [LoggingDemoController::class, 'demonstrateSecurityLogging']);
    Route::get('/channels', [LoggingDemoController::class, 'demonstrateChannelLogging']);
    Route::get('/structured', [LoggingDemoController::class, 'demonstrateStructuredLogging']);
});

// ===================================
// 8. DEMO VIEW
// ===================================

// resources/views/logging-demo.blade.php
/*
<!DOCTYPE html>
<html>
<head>
    <title>Laravel Logging Demo</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
    <div class="container mt-5">
        <h1>Laravel Logging Demo</h1>
        <p>Click the buttons below to test different logging features. Check your log files in <code>storage/logs/</code></p>

        <div class="row">
            <div class="col-md-6">
                <div class="card">
                    <div class="card-body">
                        <h5>Log Levels Demo</h5>
                        <p>Test all 8 log levels</p>
                        <button class="btn btn-primary" onclick="testEndpoint('/logging-demo/levels')">Test Log Levels</button>
                    </div>
                </div>
            </div>

            <div class="col-md-6">
                <div class="card">
                    <div class="card-body">
                        <h5>Contextual Logging</h5>
                        <p>Test logging with context data</p>
                        <button class="btn btn-success" onclick="testEndpoint('/logging-demo/contextual')">Test Contextual</button>
                    </div>
                </div>
            </div>
        </div>

        <div class="row mt-3">
            <div class="col-md-6">
                <div class="card">
                    <div class="card-body">
                        <h5>Performance Logging</h5>
                        <p>Test performance monitoring</p>
                        <button class="btn btn-info" onclick="testEndpoint('/logging-demo/performance')">Test Performance</button>
                    </div>
                </div>
            </div>

            <div class="col-md-6">
                <div class="card">
                    <div class="card-body">
                        <h5>Exception Logging</h5>
                        <p>Test exception handling</p>
                        <button class="btn btn-warning" onclick="testEndpoint('/logging-demo/exceptions')">Test Exceptions</button>
                    </div>
                </div>
            </div>
        </div>

        <div class="row mt-3">
            <div class="col-md-6">
                <div class="card">
                    <div class="card-body">
                        <h5>Security Logging</h5>
                        <p>Test security event logging</p>
                        <button class="btn btn-danger" onclick="testEndpoint('/logging-demo/security')">Test Security</button>
                    </div>
                </div>
            </div>

            <div class="col-md-6">
                <div class="card">
                    <div class="card-body">
                        <h5>Channel Logging</h5>
                        <p>Test different log channels</p>
                        <button class="btn btn-secondary" onclick="testEndpoint('/logging-demo/channels')">Test Channels</button>
                    </div>
                </div>
            </div>
        </div>

        <div class="row mt-3">
            <div class="col-md-12">
                <div class="card">
                    <div class="card-body">
                        <h5>Structured Logging</h5>
                        <p>Test structured logging for analytics</p>
                        <button class="btn btn-dark" onclick="testEndpoint('/logging-demo/structured')">Test Structured</button>
                    </div>
                </div>
            </div>
        </div>

        <div class="mt-4">
            <h3>Response:</h3>
            <pre id="response" class="bg-light p-3"></pre>
        </div>
    </div>

    <script>
        function testEndpoint(url) {
            fetch(url)
                .then(response => response.json())
                .then(data => {
                    document.getElementById('response').textContent = JSON.stringify(data, null, 2);
                })
                .catch(error => {
                    document.getElementById('response').textContent = 'Error: ' + error.message;
                });
        }
    </script>
</body>
</html>
*/

// ===================================
// 9. ENVIRONMENT CONFIGURATION
// ===================================

// .env additions
/*
# Logging Configuration
LOG_CHANNEL=stack
LOG_LEVEL=debug

# Optional: Slack webhook for critical alerts
LOG_SLACK_WEBHOOK_URL=your_slack_webhook_url_here

# Database logging (if using database driver)
LOG_DATABASE_CONNECTION=mysql
LOG_DATABASE_TABLE=logs
*/

Installation Instructions

1. Create a new Laravel project:
   composer create-project laravel/laravel logging-demo

2. Copy the files above to their respective locations:
   - config/logging.php (replace existing)
   - app/Services/LoggingService.php
   - app/Http/Controllers/LoggingDemoController.php
   - app/Http/Middleware/LogRequests.php
   - app/Console/Commands/AnalyzeLogs.php
   - resources/views/logging-demo.blade.php
   - Add routes to routes/web.php

3. Create the custom formatter directory and file:
   mkdir -p app/Logging
   # Add PerformanceFormatter.php

4. Register the middleware in app/Http/Kernel.php:
   protected $routeMiddleware = [
       // ... other middleware
       'log.requests' => \App\Http\Middleware\LogRequests::class,
   ];

5. Create log directories (Laravel will create them automatically, but you can pre-create):
   mkdir -p storage/logs

6. Run the application:
   php artisan serve

7. Visit http://localhost:8000/logging-demo to test the logging features

8. Analyze logs using the custom command:
   php artisan logs:analyze
   php artisan logs:analyze --file=user-activity.log

Feature Demonstrated:

✅ All 8 log levels (emergency, alert, critical, error, warning, notice, info, debug)
✅ Multiple logging channels (single, daily, custom)
✅ Contextual logging with structured data
✅ Performance monitoring and logging
✅ Exception logging with full context
✅ Security event logging
✅ Custom log formatters
✅ Middleware for automatic request logging
✅ Artisan command for log analysis
✅ Web interface for testing all features
✅ Different log files for different purposes
✅ Stack channels for broadcasting to multiple destinations

LOG FILES CREATED:

storage/logs/laravel.log (main application log)
storage/logs/user-activity.log (user actions)
storage/logs/api-requests.log (API calls, rotated daily)
storage/logs/performance.log (performance metrics)
storage/logs/errors.log (errors only, rotated daily)
storage/logs/security.log (security events)

Conclusion
Laravel's logging system offers powerful capabilities for tracking application behavior and diagnosing issues. By understanding the different log levels, channels, and configuration options, you can implement an effective logging strategy that provides the right information when you need it.

For the complete source code, visit:
📂 Git Repository: laravel-log-master

📌 Follow me for updates and insights:
🌐 GitHub: ArifulHaque313
🔗 LinkedIn: Md Ariful Haque Sajib

📧 Contact: asajib7654@gmail.com

📢 Hashtags:

laravel_logging #laravel#ArifulHaque313 #Ariful_Haque_Sajib #ariful_haque #sajib

Hope this makes it more visually appealing! 😊

Dockerize Laravel Vue Application! - By Ariful Haque Sajib

Ariful Haque Sajib — Sat, 03 May 2025 07:35:58 +0000

Dockerize laravel vue application — by Ariful Haque Sajib .
In this blog, I’ll walk you through setting up a Laravel 11 and Vue.js 3 with Inertia.js project in a Dockerized environment. The setup orchestrates PHP, NGINX, and MySQL services, creating a smooth development experience. Let’s break it all down.

Folder Structure
Here’s the folder structure for our project:

This structure keeps our Docker-specific files (docker/) separate from the application code (src/). The src/ The folder contains both the Laravel backend and the Vue.js frontend, which are integrated with Breeze for authentication.

In Collapse

1. Setting Up Laravel and Vue.js
I use the Laravel Global installer to install the Laravel Vue Inertia application using the steps below.

2. docker-compose.yml

docker-compose.yml defines and configures three essential services: PHP, NGINX, and MySQL.

version: '3.8'

services:
  app:
    build:
      context: ./docker/php
    container_name: laravel-vue-app
    volumes:
      - ./src:/var/www/html
    ports:
      - "9000:9000"
    networks:
      - laravel

  web:
    image: nginx:latest
    container_name: laravel-vue-nginx
    ports:
      - "8081:80"
    volumes:
      - ./src:/var/www/html
      - ./docker/nginx/default.conf:/etc/nginx/conf.d/default.conf
    depends_on:
      - app
    networks:
      - laravel

  db:
    image: mysql:8.0
    container_name: laravel-vue-db
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: laravel
      MYSQL_USER: laravel
      MYSQL_PASSWORD: laravel
    volumes:
      - db-data:/var/lib/mysql
    ports:
      - "3307:3306"
    networks:
      - laravel

volumes:
  db-data:

networks:
  laravel:

Key Points:

PHP Service (app):

Uses the Dockerfile in docker/php to build the PHP image.
Mounts the src/ folder to /var/www/html inside the container for live syncing.
Exposes port 9000 for PHP-FPM.

NGINX Service (web):

Serves the Laravel application from /var/www/html/public.
Maps the host port 8081 to the container port 80.
Relies on a custom configuration file default.conf.
MySQL Service (db):

Runs MySQL version 8.0.
Sets up environment variables for database credentials.
Stores data in a Docker-managed volume db-data.

Networks and Volumes:

A custom laravel network connects all services.
A named volume db-data persists the MySQL database data.

3. PHP Dockerfile
The Dockerfile in docker/php/ defines the PHP environment for Laravel.

FROM php:8.2-fpm

# Install required dependencies
RUN apt-get update && apt-get install -y \
    git \
    unzip \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    libzip-dev \
    && docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd zip

# Install Composer
COPY --from=composer:2.6 /usr/bin/composer /usr/bin/composer

# Set working directory
WORKDIR /var/www/html

Key Points:
1. Base Image: Uses the official php:8.2-fpm image optimized for Laravel.
2. Dependencies: Installs required extensions like pdo_mysql for MySQL, gd for image processing, and zip for file compression.
3. Composer: Adds Composer for dependency management.
4. Working Directory: Sets the working directory to /var/www/html.

4. NGINX Configuration
The NGINX configuration file default.conf is placed inside docker/nginx/.

server {
    listen 80;
    server_name localhost;
    index index.php index.html;
    root /var/www/html/public;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        include fastcgi_params;
        fastcgi_pass app:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    }

    location ~ /\.ht {
        deny all;
    }
}

Key Points:

Root Directory: Points to Laravel’s public/ folder.
PHP Requests: Forwards .php requests to the PHP service (app) on port 9000.
Security: Denies access to hidden files (e.g., .htaccess).

5. Environment Setup .env
copy and paste in Laravel .env file

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laravel
DB_PASSWORD=laravel

6. Running the Docker Containers
Start the Docker services with docker-compose:

docker-compose up -d

Access the Application:
Laravel App: http://localhost:8081
MySQL: Accessible on port 3307.

Docker Commands

Start containers

docker-compose up -d

Stop containers

docker-compose down

View container logs

docker-compose logs -f

Access PHP container shell

docker-compose exec laravel-vue-app bash

List running containers

docker-compose ps

Conclusion
This setup ensures that Laravel and Vue.js run seamlessly in a Dockerized environment. It separates concerns, making it easy to manage and scale. With services like PHP, NGINX, and MySQL running in isolated containers, your development workflow becomes efficient and predictable.

Feel free to tweak this setup based on your project’s needs. Happy coding! 🚀

For the complete source code, visit:
📂 Git Repository: dockerize-laravel-vue-app

I’m Md Ariful Haque Sajib, a Software Engineer 👨‍💻 at Adventure Dhaka Limited, specializing in PHP, Laravel, Vue.js, and React.js. With expertise in E-commerce, Payment Gateways, APIs, various Management and Finance-based software. I am passionate about 🧠 learning and delivering 🌟 high-quality solutions.

📌 Follow me for updates and insights:
🌐 GitHub: ArifulHaque313
🔗 LinkedIn: Md Ariful Haque Sajib

📧 Contact: asajib7654@gmail.com

📢 Hashtags:

ArifulHaque313 #Ariful_Haque_Sajib #ariful_haque #sajib #LaravelSitemap

Hope this makes it more visually appealing! 😊

Running MongoDB in Docker: A Simple Guide

Ariful Haque Sajib — Sat, 26 Apr 2025 11:00:52 +0000

Running MongoDB in Docker: A Simple Guide By Md Ariful Haque Sajib (arifulhaque313)

Quick Steps

Setting Up MongoDB

Pull the MongoDB image

   docker pull mongo

Run MongoDB container

   docker run --name mongodb -d -p 27017:27017 mongo

This runs MongoDB on port 27017

Check running containers

   docker ps

Connect to MongoDB

   docker exec -it mongodb mongo

Connect to MongoDB shell

   docker exec -it mongodb mongosh

Essential MongoDB Commands

Basic Database Operations

Show all databases

   show dbs

Use a database

   use db_name

Show collections

   show collections

Create a database

   db.createDatabase("database_name")

Delete a database

   db.dropDatabase("database_name")

Working with Collections and Documents

Create collection

   db.createCollection("collectionName")

Insert documents

   db.collection_name.insertOne({name: "Md Ariful Haque Sajib"})
   db.collection_name.insertMany([{name: "John"}, {name: "Sarah"}])

Update document

   db.users.updateOne({name: "Ariful Haque"}, {$set: {age: 27}})

Delete document

   db.users.deleteOne({name: "Ariful Haque"})

Data Persistence

For keeping your data when container restarts:

docker run --name mongodb -d -p 27017:27017 -v /your/local/path:/data/db mongo

Enabling Security

Create MongoDB with authentication:

docker run --name mongodb -d -p 27017:27017 -e MONGO_INITDB_ROOT_USERNAME=admin -e MONGO_INITDB_ROOT_PASSWORD=password mongo

I have a project simple project on express js and mongoDB. You can Check out,
📂 Git Repository: Crud-API-Mongo-Express

I'm Md Ariful Haque Sajib, a Software Engineer 👨‍💻. Specializing in PHP, Laravel, Vue.js, and React.js. With expertise in E-commerce, Payment Gateways, APIs, various Management and Finance-based software. I am passionate about 🧠 learning and delivering 🌟 high-quality solutions.

📌 Follow me for updates and insights:
🌐 GitHub: ArifulHaque313
🔗 LinkedIn: Md Ariful Haque Sajib
📧 Contact: asajib7654@gmail.com

📢 Hashtags:
#Ariful_Haque_Sajib #MongoDB #Docker #Database #WebDev #arifulhaque313
Hope this makes it more visually appealing! 😊