bcons.dev

bcons shows PHP errors and warnings with source file, line number, and stack trace; log messages and variable values from points you set in code; and session data, cookies, and request payload — all organized into separate tabs with time, domain, source file, and trace data. This applies to any PHP codebase where you can send the bcons HTTP header to enable message forwarding, and you view results either through the browser devtools extension or on the bcons website.

Errors and warnings with full context

Any warning or error your code produces is reported to the bcons console. Each report includes:

• Source file name
• Line number
• Stack trace

That means you don't have to reconstruct where a problem originated from a bare message. The trace data is attached to the message itself.

Log messages and variable values

bcons is described as a companion for debugging tasks such as logging messages or tracking the values of variables at set points in your code. So beyond automatic error capture, you can insert logging calls and inspect what a variable holds at a specific moment — the same role error_log() plays, but surfaced in the browser instead of a server log.

Session data, cookies, and payload

The console also displays:

• Session data
• Cookies
• Payload information

The site's own example illustrates this. A raw FastCGI stderr log shows a checkout request for order sd34s8hd, with the payload action=orderCheckout, orderId=sd34s8hd, session userId=23, and cookies PHPSESSID and userLanguage. In bcons, those same messages appear in separate tabs rather than as one dense log line.

How messages are organized

Each message carries metadata: time, domain, source file, and trace data. Messages are split across separate tabs, which is what makes the volume in the example above readable — payload, session, and cookies each get their own place instead of being interleaved.

Two interaction details from the site: all consoles shown on the bcons page are live, and Ctrl+click on any message element copies it to the clipboard.

How the data gets there

bcons sends an HTTP header that instructs the PHP code to enable sending error and debugging messages to the bcons console. The console itself is available as a browser devtools extension or on the bcons website.

What this replaces

The comparison the site draws is against error_log() and cryptic server logs. The example above is exactly that: a multi-line FastCGI stderr dump where the useful values are buried in PHP message: prefixes. bcons keeps the same information but separates it by type and attaches source and trace metadata.

Practical notes

• The site lists a three-step setup for the PHP debugger, but the excerpt only shows step 1, so the full sequence isn't reproduced here.
• Pricing and contact pages exist in the site navigation; no pricing details are given in the available material, so don't assume it's free.
• The live consoles on the bcons page are demos — clicking around them is a reasonable way to see the tab layout and message metadata before wiring it into your own project.

bcons works by sending an HTTP header that tells your PHP code to start forwarding error and debug messages to a bcons console, which you open either as a browser devtools extension or on the bcons website. This applies when you want PHP messages — logs, variable values, errors, warnings, session data, cookies, and payload information — shown in a structured browser console instead of raw server logs.

The core mechanism

The flow has two sides that meet at a single HTTP header:

1. A header is sent that instructs the PHP code to enable sending of error and debugging messages to the bcons console.
2. PHP messages are forwarded to that console as they are produced.
3. The console renders them in the browser, where you read them.

The header is the switch. Without it, PHP has no instruction to route messages to bcons, so nothing appears in the console.

Where the console lives

bcons provides its console in two forms:

• A browser devtools extension
• The bcons website

Both are described as places where the console is available, so you are not locked into a single viewing surface.

What you actually see

Messages are displayed in separate tabs, which keeps different kinds of data from collapsing into one stream. For each message, the console gives easy access to:

• Time
• Domain
• Source file
• Trace data

Errors and warnings are not just flagged — they are reported with the source file name, line number, and stack trace. That means when something breaks, you can jump from the console entry to the exact location in your code rather than searching server logs for a matching timestamp.

Why this replaces log-reading

The contrast is made explicit on the site: the alternative is error_log() and cryptic server logs. A raw log line can carry a lot of useful data but presents it as one dense string. For example, a single FastCGI stderr entry might contain the current user, an order ID, the payload array, session values, cookies, a billing-information check, and a redirect decision — all run together.

bcons takes that same material and splits it into tabs with time, domain, source file, and trace attached to each entry. The information is the same; the structure is what changes.

Practical details worth knowing

• Consoles on the bcons site are live, so you can click around in them.
• Ctrl+click on any message element copies it to the clipboard — useful when you want to paste a value or trace into an issue or a chat.

What bcons is for

The site states two main goals:

1. Display PHP messages in a clear and organized way.
2. Implement the browser Console API for PHP to help debug PHP code more efficiently.

So the design intent is not just prettier output — it is to give PHP the kind of console-driven workflow that browser JavaScript developers already use.

bcons is a PHP debugging tool that displays log messages, errors, warnings, session data, cookies, and payload information in a browser console instead of raw server logs. Setup follows three steps: enable the bcons HTTP header in your PHP code, open the bcons console (via the browser devtools extension or the bcons website), and trigger your code so messages appear. This guide is for PHP developers who want real-time debug output in the browser rather than parsing error_log() output.

What bcons Does Before You Set It Up

bcons has two stated goals:

1. Display PHP messages in a clear, organized way.
2. Implement the browser Console API for PHP to make debugging more efficient.

Once active, any warning or error in your code is reported to the bcons console with the source file name, line number, and stack trace. Log messages appear in separate tabs with access to the time, domain, source file, and trace data.

Prerequisites

• A PHP application you can edit (to add the bcons header/enabling code).
• A browser where you can install the bcons devtools extension, or access to the bcons website console.
• The bcons library available to your PHP code (the page describes the mechanism but does not list install commands, so follow the setup instructions on bcons.dev for the current package).

Setup Steps

Step 1: Enable bcons in your PHP code

bcons works by sending an HTTP header that instructs the PHP code to enable sending error and debugging messages to the bcons console. Add the bcons enabling call to your PHP entry point or bootstrap file so the header is emitted on responses you want to debug.

Input: your PHP bootstrap or entry script. Action: include the bcons initialization so the HTTP header is sent. Expected result: responses from that script carry the bcons header, and the console is authorized to receive messages.

Step 2: Open the bcons console

The bcons console is available in two forms:

Open the console before or while you load the page you are debugging.

Step 3: Trigger your code and read the output

Load the page or run the request that executes your instrumented PHP. Messages, warnings, and errors appear in the console in real time.

Expected result: log messages, errors, warnings, session data, cookies, and payload information show up in separate tabs, each with time, domain, source file, and trace data.

What You Can Inspect After Setup

• Log messages and variable values at set points in your code.
• Errors and warnings, each with source file name, line number, and stack trace.
• Session data, cookies, and payload information — the page's example shows an order checkout request where the console surfaces the current user, the requested order ID, session userId, cookies (PHPSESSID, userLanguage), and the user's billing record, all as separate messages rather than one dense log line.

Practical Tips

• Ctrl+click any message element to copy it to the clipboard — useful for pasting a stack trace or payload into an issue or chat.
• The consoles shown on the bcons.dev page are live, so you can click around them to see how tabs and message details behave before wiring up your own code.
• Compare the output to the raw alternative: the same checkout flow above would otherwise appear as a single FastCGI stderr line mixing user info, payload, session, cookies, and redirect logic — hard to scan and easy to misread.

Common Setup Issues

• No messages in the console: confirm the bcons header is actually being sent on the response. If your code path exits before the enabling call runs (early redirect, fatal error before bootstrap), the header never goes out.
• Console open but empty for some requests: check whether the request you are testing passes through the file where you enabled bcons.
• Wrong environment: if you enabled bcons only in a local bootstrap, staging or production requests will not report to the console.

When This Setup Fits

Use bcons when you want browser-side, real-time visibility into PHP errors, warnings, and runtime data without tailing server logs. If your workflow depends on server-side log aggregation or you cannot modify the PHP entry point to send the header, this approach will not fit as-is.

bcons is a PHP debugging tool that displays debug data in your browser instead of in server logs. It has two stated goals: display PHP messages in a clear, organized way, and implement the browser Console API for PHP so you can debug PHP code more efficiently. It is relevant to you if you currently rely on error_log() and server log files to trace variables, errors, or request data in PHP.

What bcons shows you

According to the site, bcons is a companion for debugging tasks such as logging messages or tracking the values of variables at set points in your code. It also displays:

• Errors and warnings
• Session data
• Cookies
• Payload information
• Log messages and variable values

Any warning or error in your code is reported to the bcons console with the source file name, line number, and stack trace.

How it works

bcons sends an HTTP header that instructs the PHP code to enable the sending of error and debugging messages to the bcons console. The console itself is available in two forms:

• A browser devtools extension
• The bcons website

So the flow is: your PHP code emits messages, the header mechanism routes them, and you read them in a browser-based console rather than in a log file.

The problem it replaces

The site frames bcons as an alternative to error_log() and cryptic server logs. Its example shows a raw FastCGI stderr dump where a single request produces a wall of PHP message: lines covering the current user, checkout request, payload array, session array, cookies array, billing status, and a redirect — all as undifferentiated text.

bcons presents that same kind of data in separate tabs, with easy access to the time, domain, source file, and trace data. In other words, the information is the same, but it is organized by type and source instead of concatenated into one log stream.

What the console experience is like

The site notes that all bcons consoles on its page are live and clickable, and that Ctrl+click on any message element copies it to the clipboard. That matters for two practical reasons:

• You can inspect real message structure before deciding whether the format fits your workflow.
• Copying a message element gives you a clean way to move a specific error or variable dump into a bug report or chat.

Where it fits in a debugging workflow

Use bcons when you want per-request visibility into errors, warnings, variable values, session, cookies, and payload without tailing a log file. The source file, line number, and stack trace attached to each warning or error make it suited to locating the origin of a problem rather than just confirming that one occurred.

The site describes setup as three steps, but the input material does not include the step details, so the exact installation and configuration procedure is not covered here. Check the bcons site for the current setup instructions before assuming a particular integration method.