DEV Community: Abdulbaki Suraj

Send PHP errors to Telegram with lograh-php package

Abdulbaki Suraj — Wed, 20 Mar 2024 14:24:41 +0000

Introduction

Error handling in PHP

Error handling is one of the critical aspects of any PHP application. When unexpected situations occur during program execution, proper error management ensures that the application can easily handle these scenarios without crashing or producing undesirable outcomes.

In PHP, the ‘try’ and ‘catch’ constructs are fundamental components of the language’s exception handling mechanism. These basically tells the source code to ‘try’ and execute a block of code and if an exception occurs, it ‘catch’es it and any action can be taken in the ‘catch’ block without stopping the running process.

Here’s a basic example of a try-catch block in action.

<?php
 try {
  // run piece of code that may throw an exception
 } catch (\Throwable $exception) {
  // log or process the exception
  echo “Caught an exception: “ . $exception->getMessage();
 }
 // do some other things

In this example, we have a ‘try’ block that might throw an exception and if one were to occur, it is caught in the corresponding ‘catch’ block and you can access any information about the exception from the ‘$exception’ variable.

The lograh-php package

Let’s say we have a scenario where you have a critical process running in your PHP project and you would like to be notified outside of your app as soon as an exception occurs. There are a lot of packages and third-party tools out there that can be used to implement, but a host of them are either too complicated to set up, have a lot of dependencies (which can impact performance) or cost you to use.

The lograh-php package is a very light-weight solution for this as it easily utilizes Telegram’s popular Bots API, allowing you to send information about these exceptions directly to any dedicated chat, group or channel on your Telegram account.

Setup

Before you can use this package, you need a Telegram Bot setup on your account. What we need here is the API Key generated after creating your Bot and your chat, group or channel ID.

Obtain your bot token

Obtaining your Bot token is a pretty straightforward process in the steps listed below.

Follow this link https://t.me/botfather to interact with the BotFather to generate a new Telegram bot.

Once it opens up, if not already selected, type in the command ‘/newbot’ in the message box or select the option from the side menu and follow through with the prompts as shown in the screenshot below.

Copy the token and keep in a secure place.

Then click on your bot link.

This takes you to a chat window with your window, then you click “Start” button at the bottom of the screen or enter the “/start” command in the message box.

Get your chat ID

Your chat ID is used to identify the chat that the logs would be sent to. This could be your direct inbox, a public/private that you have admin access to. In this scenario, we will be sending the logs directly to your chat.

Follow this link https://t.me/userinfobot to interact with the “userinfobot” to display your user info when you forward a message to it.

Click the “start” button on the bottom of the screen or type in the command “/start”.

This should show your user details.

Copy your ID and also keep in a secure place for later.

Include the lograh-php package

If your PHP project is setup with composer, you can easily import the package by running the command below

composer require codelikesuraj/lograh-php

Or you can copy/clone the project from github, https://github.com/codelikesuraj/lograh-php.

Usage

We are going to be using a skeleton project I created specifically for this tutorial, you can check out the source-code here https://github.com/codelikesuraj/lograh-tut.

Create an index.php file in the root of the project

touch index.php

Inside the index.php file, initialize an instance of the LograhPHP\Logger class with your project name, bot token and chat ID.

<?php
require_once("vendor/autoload.php");

$logger = new Codelikesuraj\LograhPHP\Logger(
    appName: "Lograh Tutorial",
    botToken: "api_key_generated_from_your_telegram_bot",
    chatId: "id_of_your_telegram_chat_or_channel_or_group"
);
...

Then add this simple try-catch block just below it.

...
try {
    throw new \Exception("I am an error from Lograh-tut");
} catch (\Throwable $exception) {
    // send exception to Telegram using any
    // of the following methods
    $logger->reportAsText($exception);
}

Now run the code and you should receive a message on your telegram that looks something like this.

php index.php

Also, for a JSON style message, you can use either use the ‘reportAsJson()’ or ‘reportAsJsonWithStackTrace()’ method which as the name suggests sends the report as a JSON without and with the stack trace respectively.

Here’s a sample of what those implementations might look like.

...
$logger->reportAsJson($exception);
...

...
$logger->reportAsJsonWithStackTrace($exception);
...

Getting started as a backend developer: A beginner’s guide

Abdulbaki Suraj — Sun, 10 Mar 2024 10:03:30 +0000

Getting started in anything these days is usually hard for beginners than people actually realize. With a huge number of resources on the web and easy accessibility from anywhere in the world, navigating the right path can be an exhausting task.

In this post, I try to get you acquainted with the backend development space, a guide on what to learn and a few lists of resources to get you started.

What is Backend Development?

Backend is a term used to describe the unseen activities that happen in the background whenever any action is taken on a website. Those actions could include signing in, creating an account, accessing resources on a web application, purchasing an item in an online store and so on.

Backend development also sometimes referred to as server-side development involves creating logic and code that interacts with a database or storage media stored on a server, a programming interface that exchanges information between the user on the frontend (the part of the website the user can see and interact with) and the database and then output necessary information back to the user.

Who is a Backend Developer?

Now that we know what backend development is, we can say that a Backend Developer is responsible for managing all activities that occurs on a web server.

Roles of a Backend Developer

Writing server-side logic with a programming language of choice
Processing data from user requests and performing actions on them
Ensuring data is only accessible to users that are supposed to have access to it
Fixing website bugs and errors
Creating and managing databases
Collaborating with the frontend to provide seamless communication between the frontend and backend
Developing and integrating APIs to connect with other backend applications and services

Getting started

Before we dive head first into Backend Development, there are a few concepts and underlying architecture we need to understand, most of which forms an integral part of whatever we are going to be discussing and doing in the future.

Prerequisite Knowledge

Having a basic knowledge of the underlying technology isn’t a waste of time. This usually proves useful in the long run and some of them include but are not limited to the following:

The Internet: How it works, what HTTP is, how browsers work, hosting etc.
Database: Types (relational vs non-relational) and their use cases.
Servers
Frontend: Have a basic knowledge of front-end technologies and languages like HTML, CSS and JavaScript. Trust me on this, understanding how your data will be displayed to and submitted by the user will help you when formatting input and output. It also helps in understanding the structure of the frontend and how to effectively interact with it.

Pick a Backend Language

Picking a language to start with is another daunting task but I will suggest starting with one and learning its perks as well as its limitation.

One good thing about learning a language is that when you decide the current one isn’t cutting it for you, learning another one won’t be hard as the knowledge of programming concepts such as loops, functions, variables etc. of one language is transferrable to other languages with a differences in its syntax and structure.

There are a few programming languages which are suitable for writing backend code but I will only be listing the commonly used ones in no particular order. These include but are not limited to the following:

NodeJS (JavaScript for writing server side)
PHP
Python
Ruby
Java
Golang and so on

Amongst the above list, I started with and still use PHP as it runs on various platforms (Linux, windows etc.) and its compatible with almost all web servers used today (Apache, IIS).
Its free to use and also easy to learn while supporting a wide range of relational databases such as MySQL which is another popular and widely used database.

After picking a language, learn basic concepts like variables, loops, functions, arrays, if-else and switch statements and then ones you have a grasp of these, take it a step further by learning OOP – Object Oriented Programming if the language supports. This is not a must yet, but you’ll eventually need to learn that.

Pick a Database Management Systems

You have learned how to write code with your preferred language but you feel like something is missing. All the codes you have been writing up till this point probably won’t have persistent data, that is, the user inputs are stored temporarily. This is where a database comes in. It helps retain such data and provides them again on request for reading and modification.

A Database Management System (DBMS) is kind of like the software used in managing the database itself. This could further be classified based on the database model they support which can be Relational databases (usually made up of a series of tables that contains rows and columns and they use a Structured Query Language (SQL) for interacting with the data) and Non-relational databases (also referred to as NoSQL, doesn’t use the tabular form of storage used by relational databases).

For starters, go with a relational database and my preferred choice would be MySQL as it pairs nicely with my preferred language which is PHP.

It is not a must for you to go with these choices, your choice of backend language and database may differ from mine, just do a bit more research and find a pair that works for you.

Learn basic CRUD operations

You must be wondering what CRUD means by now, don’t worry its nothing technical. Its just an acronym for the basic operations that occurs in the backend which are

Create: receive data from frontend and save to the database,
Read: fetch data from the database and output to the frontend,
Update: edit and update data stored in the database, and
Delete: delete data stored in the database.

There are few tutorials online (videos and articles) detailing how to go about this in your language and database of choice.

Learn authentication and authorization

After getting comfortable with CRUD operations, how about we put some privacy into it. Up until this point, any user has access to all parts of your web application. In order to prevent this and allow only certain users to have access to certain parts, information and actions on your web application, we need to add authorization logic to your web application.

This involves creating login and signup code (authentication) which only allows users to have access to other parts of your application asides the login and signup screen and then based on the type of users (whether standard or administrator) you restrict access to some other parts further inside you application.

Start building projects

If you’ve managed to persevere and get this far in your learning path, I can confidently say that you’re on your way to becoming a world-class backend developer. Since you can confidently write code to create, read, update and delete data from a database, add authentication and authorization to your application, I think you can build the next Facebook now.

I am only kidding though, but with these you can start with projects from as little as a Todo List (every beginner’s favorite) and then tune it up a bit by adding authentication and authorization in order to allow only the owners to view their own lists.

Learn a framework

You have been working on a few projects now and have begun to notice some repeating patterns, a typical example being writing login and signup logic, authorization, writing logic to save and retrieve data from the database and they are beginning to get tedious.

Some of you might have even found libraries and packages online, others may have a reusable and customizable template they created to help with them with these tasks, anyways, you are all trying to make your work easier and focus more on what matters right, and that’s where this wonderful thing called FRAMEWORKS come in.

A framework is a programming tool or set of reusable codes that come with pre-written components or solutions that can be customized in order to speed up development. Using framework can save you huge amount of time that would have been spent building things from the ground up and because of this, reduces the chances of errors.

Other reasons to use frameworks are:

reduce code duplication,
simpler testing and debugging,
you can focus on writing code that is specific to your project (more like business logic),
easily reusable,
comes preinstalled with industry-standard conventions and security measures etc.

Frameworks are usually built on top of existing programming languages some of which include but are not limited to the following:

PHP – Laravel, Symfony, CodeIgniter, Yii, CakePHP etc.
Python – Django, Flask etc.
NodeJS (JavaScript) – Express.js, Meteor.js etc.
Ruby – Ruby on Rails, Sinatra, Camping etc.
Java – Spring etc.
Golang – Fiber etc.

Final notes

One simple strategy that has always helped people to grow in this field is to learn by doing. Don’t get caught up watching tutorials, reading blog posts and never actually taking your time to practice all you have learned, take time after learning to apply this by building projects. Most people make a mistake of learning a lot of theory without actually applying it.

It doesn’t matter if you picked up some dude’s code from the internet, take your time, read it, yes, I know what I said, read the code. Understand the purpose and what every function is trying to achieve then try recreating it by building your own.

You need not create an exact copy of the project but provided you understood what it was trying to achieve and the process that was taken to achieve then you’re good.

Take your time, understand concepts and keep on improving on your skills. Join communities and reach out whenever you are having issues and let google be your best friend. Even senior developers still search for a few things once in a while 😊.

There is still a lot more topics to discuss and expand on, but that's not the purpose of this post. Its only but a guide as you will discover other topic and concepts I didn't talk about here.

Have fun learning 👋. See you around.

Simple HTML form validation with PHP (a step-by-step guide)

Abdulbaki Suraj — Wed, 28 Feb 2024 11:35:34 +0000

In this tutorial, I'll be showing you how to perform a simple HTML form processing/validation using PHP. For the tutorial, we will build a simple user form that request for their full name and displays a welcome text after the user has entered their details in the html form and submitted.

Let's get started!

1) Setting up your environment

If you already have your test environment ready, you can skip this step and jump to creating the file.

For us to be able to properly view and test our application, we need to have some tools in place:

A browser (I will be using [Google Chrome Browser](https://www.google.com/chrome)): Any browser will do.
A text editor (I am using [Sublime Text 3](https://www.sublimetext.com/3)): This is to create, edit and save our code.
A local web server installed (I use [XAMPP](https://www.apachefriends.org/download.html) on windows 10): To simulate an http-server on your computer.

In case you run into some trouble setting up XAMPP, you can check out this tutorial.

After all that is done, the next thing for you to do is to go into the "htdocs folder inside your XAMPP installation directory (mine is - C:\xampp\htdocs) and create a new folder (I'll name mine "form"). You can name it anything you want.

Next, open Sublime Text 3 and create a new file (ctrl + n).

Copy and paste the following code into it


<?php
echo ( "Hello world!" );
?>

Then save it as index.php inside the folder you created.

Next step after ensuring the XAMPP server is running is to go to your browser and type this into the URL bar http://localhost/name_of_your_folder. Your browser screen should look something like this.

If all goes well, you can proceed to the next step.

2) Writing the HTML for the form

In your index.php file, clear any previous code there and copy and paste the following into it.

<?php
/*php main code goes here*/
?>
<!DOCTYPE html>
<html lang="en">
<head>
    <title>My Form</title>
</head>
<body>
    <h2>My form</h2>
    <form method="post">
        <?php 
        /* php error and display code goes here */
        ?>
        Name: 
        <input type="text" name="username"><br><br>
        <input type="submit" name="submit_form" value="SUBMIT">
    </form>
</body>
</html>

This is just a simple html form with an input field and a submit button. After this is added, save (ctrl + s) again on the text editor and reload the page on the browser.

Cool, now we have our form, but typing stuffs into the box and clicking the submit button won't do anything.

Alright, let's move on to the real deal and probably what brought you here in the first place - creating a few lines of PHP 🐘 code.

3) Writing the PHP test cases

Note that in the HTML form earlier, our method attribute was "post" <form method="post">, this is how the data entered by the user is transferred to the server and we shall be making using of $_POST['name_in_form'] function to retrieve our data. Here are some of the conditions we are going to be checking for:

Check if the user submitted an empty field - this will be checked using the [empty(str) function](https://www.w3schools.com/php/func\_var\_empty.asp),
Check if the user submitted a numeric value - this will be checked using the [is_numeric(str) function](https://www.w3schools.com/php/func\_var\_is\_numeric.asp),
Check if the number of words submitted is less than 2 so as to ensure the user submits at least a first and a last name - this will be checked using the [str_word_count(str) function](https://www.w3schools.com/php/func\_string\_str\_word\_count.asp).

Copy and paste the following code just below the line where you have /* php main code goes here */:

if ( isset( $_POST['submit_form']))
{
    //create a variable to store the display message
    $display = '';      

    //assign the value of $_POST['username'] to $full_name variable
    $full_name = $_POST['username'];

    //check if there is no data in the variable
    if ( empty($full_name))
    {
        $display = "Error: Input is empty, please enter a name !";
    }

    //check if the data is a number
    else if ( is_numeric($full_name) )
    {
        $display = "Error: Name cannot be numeric";
    }

    //check if the number of words is not less than two
    else if( str_word_count($full_name) <= 1) 
    {
        $display = "Error: Please enter a valid first and last name";
    }

    //if all the above conditions are false
    else
    {
        $display = "Hey ".htmlentities($full_name).", you are awesome :)";
    }
}

I added a lot of commenting in the code in other to make it self-explanatory.

And also copy the following code just below the line where you have /* php error and display code goes here */

//display the variable if a value has been set
if ( isset($display))
{
    echo "$display";
}

The above code allows us to visually see the errors they encounter during the validation process.

To avoid PHP errors from disrupting the screen, the isset($display) condition is used to ensure the variable is set (that is, a value has been passed into it) before there is any reason to display anything.

Below are screenshots of the application displaying the errors.

And here's a bonus 😉 screenshot of me entering correct values.

Thank you for following me till the end of the tutorial and I hope you have learned something new too.