It should be noted that this setting DOES NOT suppress the error. Even if the directive is set to ‘Off’ (do not display errors) errors which occur in a script are still triggered and will be processed by the error handler.

</IMPORTANT>

 
PHP does not offer a special display_errors function, but by using the ini_set() function we can control the setting of this directive within our script. The function signature looks like this:

string ini_set ( string $varname , string $newvalue )

blah, blah

The configuration option I would like to address in this article is, of course, error_reporting.

Let’s start digging.

error_reporting

The error_reporting directive (within the PHP ini file) allows you to set the level of errors reported by PHP. By default this is set to ‘E_ALL & ~E_NOTICE’. This ‘tells’ PHP to report all errors, except Notices.

PHP provides a built-in function for getting and setting the error_reporting level: error_reporting(). The function signature looks like this:

int error_reporting ([ int $level ] )

The function accepts one optional argument, a new error reporting level, and returns the old error reporting level. Although the signiture shows that the function accepts an integer, the new level sent can be represented by a predefined constant. In fact it is recommended that you use the predefined constants to ensure future compatibility.

The available constants can be used in combination to build up a bitmask; the bitmask tells PHP which errors to report and which to suppress. Since these constants are actually bitmasks, you will need to use bitwise operators when combining them.

An example of the error reporting setting I use in development is:

$old_setting = error_reporting(E_ALL | E_STRICT);

From the predefined constants chart the setting E_ALL equates to the integer 30719 and means:

All errors and warnings, as supported, except of level E_STRICT in PHP < 6.

From the predefined constants chart the setting E_STRICT equates to the integer 2048 and means:

Enable to have PHP suggest changes to your code which will ensure the best interoperability and forward compatibility of your code.

So basically, this tell PHP to report all errors, notices, and messages generated at the E_STRICT level.

Back to the code…

The variable $old_setting will now be set to: 6135, the default setting for error reporting (using the predefined constants again that would be: E_ALL & ~E_NOTICE).

A small code example:

<?php
//get the current error reporting setting
$current_setting = error_reporting();

//check if error reporting is set to E_ALL | E_STRICT
if (8191 != $current_setting) {
    //not set to E_ALL | E_STRICT make it so
    error_reporting(E_ALL | E_STRICT);
}

//display new error reporting setting

echo error_reporting(); //displays 8191
?>

A more useful example would be to change the error_reporting setting based on the environment the script is being run in.

Let’s say you have a configuration file which defines the constant ‘ENV’, this can be set to ‘production’ (live site) or ‘development’. If the script is run in production then we want to use ‘E_ALL & ~E_NOTICE’ (default), but when running in development we want to use E_ALL | E_STRICT.

config.php:

<?php

//define enviroment
define('ENV', 'development');

Script File:

<?php

//load configuration file
require_once('config.php');

//check ENV constant to see if running in development
if ('development' == ENV) {
    //running in development so change default setting
    error_reporting(E_ALL | E_STRICT);
    //now all errors, notices, and suggestions will be reported
}

That’s it! I’m sure you can see how useful this function can be.

Side Note: If you are unsure what a bitmask is or are unfamiliar with bitwise operators, you may want to checkout this post from joestump.net.

When I first started learning about errors and error handling I found numerous tutorials on the topic, but none that provided a complete resource on the subject. This is understandable; since the topic is so broad one tutorial would not only be extremely long, it might also seem overwhelming to someone who just started learning about the topic. This is also the reason it would make a great topic to cover on a blog, where a series of posts can be created, each building on the information presented in the previous post ending with a comprehensive  resource. (OK, comprehensive maybe a little strong but hopefully it will be close.)

The intended outline for the series is:

Resource Information

• Error Messages Deciphered (Revised)
• Error Reporting
• Displaying Errors
• Error Logging
• Backtrace Functions
• Triggering Errors
• Understanding Exceptions

Implementation

• Creating A Custom Error Handler
• Utilizing Exceptions
• Creating an Exception Hierarchy

Putting it all together

• Error Handling Strategies

If your using twitter and are reading this blog I’m sure you are aware of hashphp. If not, it is a twitter account which grabs most of the tweets with the hashtag ‘#php’ and re-tweets the messages. Since this seemed like a fairly simple thing to do I decided to create my own twitter feeder. Again, I was just hacking together a script, so if you use the code presented you will want to make some enhancements before letting it into the wild. (Please see end of post.)

First, I decided to pick a hastag which was used in the range of 3 – 5 times every 15 minutes; ‘#mysql’ seemed to fit the bill.

Now I needed a twitter account to re-tweet the messages, and a bit.ly account to create short URLs to link back to the original account that posted the message. I created a ‘poundmysql’ account (The number sign ‘#’ is sometimes referred to as the ‘pound’ sign in the US), then I went to bit.ly and signed up for an account.

Continuing to gather the pieces of the puzzle, I looked through the published PHP libraries on twitter and found one which did exactly what I needed. There were other more robust scripts, but I only needed to update an account status so grabbed the package Twitter by Felix Oghina. The next piece came in the way of the Bitly class, written by Ruslanas Balciunas. (I apologize to Ruslanas Balciunas but my current character set in MySQL will not allow for a proper spelling of the last name.)

Next, I needed to be able to retrieve all the tweets which contained the string #mysql. Twitter offers a Search API which would do the job, but for my purposes search.twitter was the faster option. They offer an XML feed to any search so I only needed to search #mysql and grab the URL of the feed, which is:

http://search.twitter.com/search.atom?q=%23mysql

As you can see the search term is contained in the query string of the URL (URL encoded), which is useful since I could then setup the script to accept any search term.

OK, now with all the pieces of the puzzle at hand I only needed to write the code to fit the pieces together creating my own twitter feeder.

First I grabbed a function which I used in a long ago project [probably also swiped from the internet:)]. The function sends a HTTP request to a server and returns the response.

function url_get($domain, $uri, $referer='')
{
    $header = array();
    $header[] = 'GET '.$uri.' HTTP/1.1';
    $header[] = 'Host: '.$domain;
    $header[] = 'User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US;rv:1.8) Gecko/20051111 Firefox/1.5';
    $header[] = 'Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5';
    $header[] = 'Accept-Language: en-us,en;q=0.5';
    $header[] = 'Accept-Encoding: gzip,deflate';
    $header[] = 'Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7';

    $header[] = 'Keep-Alive: 300';
    $header[] = 'Connection: keep-alive';

    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $domain.$uri);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($ch, CURLOPT_ENCODING, "");
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
    curl_setopt($ch, CURLOPT_REFERER, $referer);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $header);

    $result['exec'] = curl_exec ($ch);
    $result['info'] = curl_getinfo($ch);

    curl_close ($ch);

    return $result['exec'];
}

As you can see the function accepts three parameters, the domain to connect to ($domain), the path to the requested page ($uri) and the referrer ($referer). This function uses the cURL extension, if your PHP configuration has allow_url_fopen turned on you don’t even need this function (more on that in a minute).

Next I setup the $domain, $uri and $search_term variables, and made the call to the function to get the XML from search.twitter.

//ideally you would put this in a configuration file
$search_term = '#mysql';

//create variables to be sent to the function
$domain = 'search.twitter.com';
$uri    = '/search.atom?q='.urlencode($search_term);

//retrieve the xml response string from search.twitter
$feed = url_get($domain, $uri);
 

Now that the script has the information needed from twitter as an xml string, I can then create a SimpleXML object using the following:

$xml = new SimpleXMLElement($feed);

If allow_url_fopen is set to ‘on’ you could skip directly to creating the SimpleXML object by using the URL as the first parameter and setting the third parameter to TRUE:

$feed = 'http://search.twitter.com/search.atom?q='.urlencode($search_term);

$xml = new SimpleXMLElement($feed, NULL, TRUE);

The tweets in the feed are ordered by the time they were originally posted using the UTC timezone, since this is the case I needed PHP to use UTC when calling date time functions. To do this I used the date_default_timezone_set function.

date_default_timezone_set('UTC');

Next I included the Twitter class and the Bitly class into the script and created new instances of each:

//require the two files which define the classes used
require_once('Twitter.class.php');
require_once('bitly.class.php');

//setup log in information for twitter and bit.ly
//again these should really be kept in a separate config file
//outside the document root
$twit_uname = 'twitter_username';
$twit_pword = 'twitter_password';

$bit_uname = 'bit.ly_username';
$bit_api   = 'bit.ly_api_key';

//instantiate new objects
$twitter = new Twitter($twit_uname, $twit_pword);
$bitly   = new Bitly($bit_uname, $bit_api);

The idea is to loop through the messages received from the search and update the twitter account with any message that was posted within the last 15 minutes. I setup the last run time of the script outside the loop so that it only needs to be calculated once.

//define the number of minutes between each script run
//again this is a setting which should be in the config file
$time_interval = 15;

//get the number of seconds since the UNIX epoch
//and the last script run
$last_run_time = mktime()-($time_interval*60);

The messages can be found in $xml->entry. Within the loop the first check I needed to make was to determine if the twitter feeder account (poundmysql) had posted the message and if so, skip that message.

//setup messages loop
foreach ($xml->entry as $update) {
    //skip any messages set by poundmysql
    if ('poundmysql' == $update->author->name) {
        continue;
    }
...

Next I checked for the time the message was posted and if that time occurs later than 15 minutes ago, I could end the loop and the script itself, since any entries after this would also occur after the 15 minute cutoff point.

...
    //time format in xml string: 2009-07-25T20:32:13Z
    //split time from date
    list($pub_date, $pub_time) = explode('T', $update->published);
    //remove the ending 'Z' from time
    $pub_time = substr($pub_time, 0, -1);

    //get time segments for mktime() call
    list($hour, $minute, $second) = explode(':', $pub_time);
    list($year, $month, $day)     = explode('-', $pub_date);

    //get the number of seconds since the UNIX epoch
    //and the time the message was posted
    $publish_time  = mktime($hour,  $minute, $second,
                            $month, $day,    $year);

    //check if message was later than last run time,
    //if so end loop
    if ($publish_time < $last_run_time) {
        break;
    }

If the message passes these two checks, I know that it will be used in the feeder.

I then create a bit.ly link for the original message ($update->link[0]['href']), and store the character length of the link. Then I grab the content of the message ($update->title) and store that character length.

    //grab url of the original message, create short link, store length
    $link       = (string)$update->link[0]['href'];
    $short_link = ' ..'.$bitly->shortenSingle($link);
    $short_len  = strlen($short_link);

    //grab tweet content store length
    $content     = (string)$update->title;
    $content_len = strlen($content);

Since Twitter has a max character length of 140, I then needed to check what the character length of the new message was with the bit.ly link added, if it was longer than 140, I then needed to cutoff a section of the original message to accommodate the 140 maximum length.

    //total message length
    $len_total = $short_len+$content_len;

    if (140 < $len_total) {
        //determine how many characters over 140
        $over = $len_total-140;

        //remove that many characters from the original message
        $content = substr($content, 0, -$over);
    }

The only thing left to do was to actually update the twitter status.

    $new_status = $content.$short_link;
    //update twitter status
    $twitter->update($new_status);
}
//end loop

That ends the PHP code for my twitter feeder, now I setup a cron job to run every fifteen minutes and I have my own twitter feeder feeding the MySQL community.

Since I didn’t want to actually monitor this feed, I let it run for awhile and once I verified everything was working correctly I deleted the twitter account and stopped the script from running.

A copy of the code used in this post can be found here.

Enhancements

Some updates you will probably want to make before actually using this script for a real twitter account:

• Remove all the configuration options to their own file and store outside the document root.
• Error checking for unavailable third-party services
• Reverse tweets before running the loop. ATM: the script re-tweets in the reverse order the original messages were posted.
• Implement a filtering system so no unwanted messages are inserted into your stream.
• Update the script to use the twitter search API to guarantee that all tweets with your hashtag are captured.

Back Story

It seems forums have sort of lost their luster for many; I remember when having a website meant having a forum. At that time it seemed every contract I landed, some portion of the job consisted of integrating a forum into a site. I always hated this job, because at the time PHPBB was the forum of choice and it seemed that there was no ‘right’ way to do it, I had simply developed a bunch of hacks which needed to be scattered around the PHPBB code base and even when complete it was still just a bunch of hacks.

As time moved on, the demand for forums became less and less and I had not done a forum integration in many years. That was until I went to my local PHP users group and ended up with a contract to do a forum integration. I really was not looking forward to the project, but it was a part of a larger job and I’m not one to turn down work.

Luckily the other members of the group convinced the client to use FUDforum developed by Ilia Alshanetsky. I had looked into FUDforum before, had used it as a member of different sites, and assumed the code to be a higher quality simply because of who wrote it, but had never written any code to interact with it.

On Wednesday, the night before I was to do the forum integration I began reading the documentation and planning how I was going to accomplish this task as easily and painlessly as possible. Looking at the sidebar navigation on the documentation wiki, I was surprised to see the heading ‘Integration‘ two clicks later, a quick scan of two different pages, and I knew exactly what needed to be done.

After a few hours of work Thursday morning I had written a script which created accounts in the forums for existing members, I also altered the sign up, login, and logout code of the main site. With these changes the forums were basically integrated into the site, which brings me to the new tutorial series I will be posting over the next week.

Integrating FUDforum

Part 1: Introducing your site to FUD

I have been working with this client of a few years now and have a great rapport with them. For this most recent project they have no requirements about which JavaScript library to use just as long as it has the functionality which is required by the project. This left me in a little bit of a dilemma, which JavaScript library should I use?

I have tried many libraries in the past and had used the Yahoo! User Interface Library (YUI) extensively for a previous project. Although it’s a good library I have had the urge to try out Dojo. I first learned about the library when it came coupled with the Zend Framework. After a few small personal projects I never really used either again.

Doing a little research on Dojo’s current capabilities and verifying that it has the functionality required for my project, I have decided to use Dojo and document my experience here. I’m hoping that even if you currently use a different JavaScript library that this set of posts will inspire you to try something new for a change.

My first task will be to build something similar to the ‘Suggest’ functionality on Google. This afternoon I attempted to find a good tutorial explaining how this is accomplished in Dojo, but could not locate exactly what I wanted. The problem seems to be that all the combo box / auto complete tutorials for dojo create a select menu rather than a simple text box and since this is going to be implemented for a search engine the select menu option is not actually an option. (Get it ’select menu’, ‘option’…programming humor my wife loves it.)

Over the next few days I will be working on this project and will have one or two more posts detailing how I implement the functionality. If anyone has not heard of Dojo or has never used it here are a few links to get you started.

Dojo Links

• Homepage
• Download
• Documentation
• Hello World Tutorial

My next post will assume you already have Dojo installed and have worked through the ‘Hello World’ tutorial. Here are some brief notes about installing Dojo.

Dojo Installation

When installing Dojo you have three options

• Load the toolkit directly from AOL’s Content Distribution Network (CDN) or from the CDN of Google.
• Download and store the toolkit on your server
• Checkout a copy from the SVN repository (maybe not the greatest idea if your implementing on a live site)

I believe the first two options are completely viable for a live website and each have their pros and cons. I choose to download the toolkit and keep it on my server. The upside is that since I have the files locally I can open them up and browse through the code whenever I would like (you can learn a lot this way).

In my opinion…

When attempting to update an existing site with the newest gadgets available, it is best to take slowly. Implement a few updates at a time, without forcing the users to change the way they use the site. The response received from the users will tell you what is worth it and when you’ve gone too far.

I completely disagree with this point of view. If I write code which is not intended to generate Notices, then as the developer I want to know if and when Notices are being generated in any environment.

Notices are very helpful in tracking down logical errors or bugs, which cause the script not to function as expected. In PHP they are normally generated when using a previously undeclared variable. Technically speaking there is nothing wrong with this in PHP, other programming languages are not so forgiving.

I personally started declaring all variables when I began to focus on the security implications of using undeclared variables (we’ll save that information for another post). After getting in the habit I found that I was able find logical errors during development even before I noticed that a bug existed. After realizing this, I now never release code which is know to generate notices. I have also started setting error reporting to E_ALL in all environments.

I understand that this is not feasible for everyone. It may not be possible in a professional working environment because of dealing with legacy code. Another issue could arise if you use third-party code which has not subscribed to this way of thinking. Although personally, I feel this is not an excuse there is no reason you can’t get in there and ‘fix’ their script.

A word of warning

I was once hired to fix numerous bugs on a site, all were a fairly obvious fix, but one in particular had me stumped. I turned on notices when attempting to debug the problem and ended up with an error log that contained over 250 notices for every page load. Since this was a dev environment setup by the client for my use, it was no big deal, but if it were a heavily trafficked live site, there could have been some serious implications.

While writing some validation code I came across this “trick” which can be used to determine if a file is an image file: Send the uploaded file through getimagesize() and check the return values.

As the PHP Manual states:

PHP Manual

The getimagesize() function will determine the size of any given image file and return the dimensions along with the file type and a height/width text string to be used inside a normal HTML IMG tag and the correspondant HTTP content type.

If PHP cannot access the file or the file is not an image, the function will generate an E_WARNING error, and return boolean FALSE. The E_WARNING error can be suppressed by using the error suppression operator ‘@’. As long as you know that the file is accessible to PHP (which it should be if PHP uploaded the file) and the function does not return FALSE, then you have a valid image file.

I first leaned about this method from the book php|architect’s Guide to PHP Security by Ilia Alshanetsky.

First I would like to say that I like the look of the new manual; it seems cleaner with well defined areas. For example on a function description page the description, parameters, return values, errors/exceptions, and examples all appear in their own ‘box’ (div tag) with a light blue background. This definitely makes it easier to locate what your look for and generally gives a nice presentation of the information.

My two gripes about the new manual are fairly petty. I think it is a case of ‘Who moved my cheese‘, instead of actual issues with the manual.

Gripe 1: There is too much spacing between items in the unordered lists.

Looking at what I believe to be the CSS styling for the ‘li’ tags, they have added a top and bottom padding of 3 pixels (6 pixels between each line). Although this makes for good separation between each item it also makes the pages longer and consequently more scrolling.

Gripe 2: The new navigation system, specifically in two areas:

• The index page of the manual. The old index page, was basically like an extended table of contents. It listed the sections of the manual along with the major subsections. This was always my starting point. You may not find exactly what your looking for in the first click but you knew where you wanted to go. The new index page, contains the list of sections in the left-hand navigation bar, but the page does not list any subsections. New users of the language I believe will find it more difficult to locate the information they need simply because they may not know exactly what their looking for. Now, of course, users already familiar with the language will still be able to find what there looking for but it will take more clicks to get where your going, specifically for the function reference section…
• In the old manual when you viewed the function reference section you were presented with a long alphabetized list of groups of functions; Arrays, MySQL, Strings, etc. Now they have grouped the groups; array functions are listed below ‘Variable and Type Related Extensions’, string functions are listed below ‘Text Processing’ and MySQL functions aren’t actually listed on the page, they are under ‘Database Extensions->Vendor Specific Database Extensions->MySQL’. Now I am all for more organization, but by grouping the groups the function reference is no longer alphabetized and the added clicks needed to get to the section you want I feel is not a bonus.
• This also comes into play after you have chosen the section you want. For example, in the old manual you could be looking at the array functions, find what you need, and just leave the browser open to the array functions page while you went back to work. Then after a bit more work, if you needed to look at the string functions, you could simply click the ’string’ functions link in navigation bar and be there in one click. This is not possible in the new manual…Given the same situation you always need to go back to the main function reference page and start drilling down from there.

I don’t want this to come off as a bashing of the new manual, these are minor issues and I probably just need to get used to the new setup. So now that you read my review, let us know what you think of the new manual.

While visiting he was in the middle of writing a small script which queried articles out of a database and displayed them according to the categories they were assigned to. Everything was working correctly, but the processing time was slower than he would like. He asked if I could take a look and see if anything could be done to speed things up. While optimizing some of the PHP and SQL code; I was showing him different functions which are built into PHP and MySQL, (these functions will always execute faster than the ones you write yourself).

As I was standing over his shoulder pointing out the different problematic areas, he asked me how I was able to keep all that information in my head. I simply replied that it is my job, it’s what I get paid to do. After going back and forth, what he actually wanted to know was how I memorized all the different functions, which parameters they accept, and in what order. This is not the first time I have been asked this question so I decided to actually think about how it all happened.

I once read the book ‘On Writing’ (by Stephen King), it is a book about how to become a writer. I don’t really remember a lot about the book, but I do remember one thing. He said that if you want to be a writer, you need to write everyday. It does not have to be anything great, just write something. I attempted to do this, but it became a chore and I soon stopped writing.

After thinking about the question my friend asked (I admit I have a horrible memory) but just like King said, do it everyday. I learned PHP simply by writing code everyday, by using PHP constantly, and little by little things sink in and stay. I never sat down with the manual and made an effort to memorize things, it just naturally happened over a period of time.

When I first started, I remember the fascination I had with writing something that made a computer do what I wanted. It was almost like an addiction, once I got it to do one thing, I wanted write something more complicated. Granted over the years it takes more, but I am now writing more complicated code and when it works, I get that same feeling.

So if you want to become a coder that is able to write scripts off the top of your head, or be able to ’see’ the code before you even begin, do it everyday. It does not have to be ground breaking or a completely new idea, just write something. If you find that writing code everyday becomes a chore, then you may want to try your hand at something else, maybe become an author.