Tout d’abord, un grand merci à Christian pour m’avoir aidé avec la traduction!
Cela fait plusieurs années que Google a commencé à faire d’énormes améliorations dans sa capacité à crawler et à rendre le contenu chargé avec Javascript de la même manière qu’un véritable utilisateur avec un téléphone mobile le verrait.
Néanmoins, Google ne sera pas en mesure de crawler toutes les URLs qu’il trouve, même s’il améliore son infrastructure, car le coût du crawl et du rendu (le processus de transformation d’un document HTML en une structure visuelle) est bien plus important que celui du crawl et de la récupération du code HTML d’une URL. Google l’a reconnu lui-même, il est donc important de s’assurer que Google trouvera, rendra et indexera les URLs les plus importantes de notre site, en particulier pour les sites de grande taille et/ou les sites qui dépendent de l’exécution de JS par le client (CSR, Client Side Rendering).
Il y a quelques années, pour évaluer le contenu d’une URL et décider de l’ajouter ou non à l’index, Google se contentait d’obtenir le HTML de l’URL (ainsi que les images qui y étaient liées). Ce HTML était le contenu que Google utilisait pour indexer et classer l’URL, sans tenir compte du fait que ce HTML était modifié ou non par Javascript après le rendu.
Aujourd’hui, avec l’essor des frameworks Javascript qui modifient le HTML côté client, Google doit obtenir le HTML, le code JS, les styles CSS et d’autres ressources (comme les images, les fronts, etc.) afin de rendre le contenu et d’obtenir le HTML final, pour pouvoir décider s’il doit être indexé ou non.
L’ensemble de ce processus ne se fait pas en une seule fois comme le verrait un utilisateur normal : il se déroule en deux étapes. Tout d’abord, Google explore l’URL et récupère le code HTML « non rendu » (comme il l’a fait jusqu’à présent), puis, un peu plus tard (sans qu’un délai précis soit fixé), il récupère le reste des ressources référencées dans ce code HTML et tente de rendre la page pour obtenir le code HTML final rendu. Cette deuxième étape est appelée « deuxième vague d’indexation« .
Il n’est pas nécessaire d’avoir de grandes connaissances techniques pour comprendre que, afin d’explorer et d’indexer un certain nombre d’URL, le coût de leur rendu est beaucoup plus élevé que celui de l’obtention du HTML non rendu, tant en temps qu’en ressources. Ainsi, en utilisant la même quantité de ressources finies, Google sera en mesure d’explorer et d’indexer moins d’URL s’il doit les rendre. C’est pourquoi Google doit décider/prioriser les URLs à rendre et celles à ne pas rendre.
Pour décider quelle URL doit être explorée ensuite, Google calcule la probabilité que cette URL ait changé depuis la dernière fois qu’elle a été crawlée, en tenant compte d’autres facteurs comme le PageRank de chaque URL ou si le webmaster a configuré un paramètre spécifique concernant la fréquence de crawl. C’est logique, car il est inutile de consacrer des ressources limitées au crawl de sites qui n’ont pas changé.
J’aimerais partager cet article avec vous car je pense qu’il n’est pas vraiment connu et qu’il peut être très révélateur pour comprendre comment Google décide de la prochaine URL à crawler. Il a été écrit par les ingénieurs de Google et il s’agit d’une abstraction mathématique pour résoudre un problème réel. Ne soyez pas effrayé par les formules mathématiques, elles sont parfaitement expliquées pour les personnes qui ne sont pas des spécialistes des données.
Après avoir décidé de l’URL à explorer, Googlebot doit décider, pour chaque URL explorée, s’il doit la rendre ou non, et s’il décide de la rendre, il aura besoin de toutes les ressources nécessaires pour y parvenir. Afin de décider s’il doit demander chacune des ressources nécessaires, il utilise probablement un processus mathématique similaire, mais avec quelques différences comme les temps de cache, le coût d’obtention de la ressource, etc.
En raison de tout cela, il est très important de savoir quelles URLs de notre site sont explorées par Google, et aussi lesquelles sont rendues. Un moyen facile d’obtenir cette information, que nous utilisons chez Funnel▼Punk (où nous travaillons avec de gros sites web), est d’analyser les logs du serveur (il y a un article à ce sujet sur mon blog en espagnol, et un autre sur le blog d’Oncrawl), pour obtenir une image complète de ce que Googlebot fait sur notre site. L’analyse des logs peut être fastidieuse et coûteuse pour beaucoup de gens, c’est pourquoi je voudrais partager avec vous un moyen de suivre les URLs qui sont rendues par Googlebot dans Google Analytics.
[Étude de cas] Gérer le crawl du robot de Google
Suivi des URLs rendues par Google
La méthode est relativement simple, du moins pour toute équipe de développement et pour tout webmaster habitué à travailler avec PHP ou similaire. Elle comporte 3 étapes :
- Ajouter du code javascript
Le code détectera si Googlebot a exécuté Javascript de la même manière qu’un utilisateur normal le ferait, et chargera une image en utilisant Javascript (un pixel transparent). - Configuration du serveur
Configurer le serveur pour qu’il exécute un fichier PHP (ou tout autre langage de programmation utilisé dans le backend) lorsque l’URL du pixel transparent est demandé. - Envoyer les données à Google Analytics
Notre fichier PHP vérifiera si Googlebot est vraiment Googlebot et, si c’est le cas, enverra les données à Google Analytics.
Ajouter du code javascript
Dans les différentes expériences que j’ai menées, j’ai vérifié que Googlebot n’exécute Javascript que lorsque le code Javascript ne nécessite pas d’interaction avec l’utilisateur. Par exemple, Googlebot exécutera tout code Javascript qui est déclenché par les événements onload ou onready. Dans cet exemple, nous allons créer une fonction qui sera déclenchée par l’événement onLoad, c’est-à-dire lorsque tous les éléments de la page sont chargés.
Cette fonction vérifiera si l’agent utilisateur contient l’un des bots connus de Googlebot et si c’est le cas, elle chargera une image (un pixel transparent), que nous nommerons TransparentPixelGooglebot.gif.
<script>
window.addEventListener("load", function(){
var botPattern = "googlebot|Googlebot-Mobile|Googlebot-Image|Google favicon|Mediapartners-Google";
var re = new RegExp(botPattern, 'i');
var userAgent = navigator.userAgent;
if (re.test(userAgent)) {
var client = new XMLHttpRequest();
var trackRenderURL='https://www.mecagoenlos.com/TransparentPixelGooglebot.gif?OriginUrl='+window.location.href;
client.open('GET',trackRenderURL);
client.setRequestHeader('Content-Type', 'text/plain;charset=UTF-8');
client.send(null);
}
});
</script>
Chaque fois que Googlebot accède et exécute du Javascript, notre fonction sera déclenchée, chargeant l’image « TransparentPixelGooglebot.gif », ajoutant à l’URL de l’image des paramètres où nous spécifierons l’URL spécifique qui a été accédée.
Dans cette variable, nous composerons l’URL complète qui sera demandée pour charger notre image « TransparentPixelGooglebot.gif », où nous ajouterons l’URL consultée ainsi que l’agent utilisateur qui la demande.
var trackRenderURL='https://www.mecagoenlos.com/TransparentPixelGooglebot.gif?OriginUrl='+window.location.href;
Configuration du serveur (.htaccess)
L’étape suivante consiste à configurer notre serveur de sorte que chaque fois que l’URL du pixel (TransparentPixelGooglebot.gif) est demandée, un fichier PHP est exécuté (GooglebotRenderJS.php).
Pour ce faire, nous devons apporter quelques modifications à notre fichier .htaccess (puisque nous utilisons un serveur Apache et PHP comme langage de programmation).
Ces deux lignes spécifiques sont celles qui permettront d’y parvenir :
RewriteCond %{REQUEST_URI} TransparentPixelGooglebot.gif
RewriteRule TransparentPixelGooglebot.gif(.*)$ https://www.mecagoenlos.com.com/GooglebotRenderJS.php$1Comme vous pouvez le deviner, les paramètres inclus dans la requête de pixels sont propagés afin que le fichier PHP (GooglebotRenderJS.php) puisse les « lire ».
Envoyer les données à Google Analytics à partir du fichier PHP
Dans notre dernière étape, nous créons le fichier PHP (GooglebotRenderJS.php) qui sera exécuté chaque fois que le pixel (TransparentPixelGooglebot.gif) sera demandé.
Ce fichier va:
- Vérifier, en utilisant le DNS inverse, si la demande a été réellement faite par Googlebot ou un faux Googlebot en utilisant l’agent utilisateur de Googlebot.
- Identifier le type de robot dont il s’agit (Googlebot Mobile, Images, Ads, etc.)
- Envoyer les données à Google Analytics (en utilisant le protocole de mesure de Google Analytics) à l’intérieur d’un événement où nous attribuerons les variables suivantes :
- Catégorie d’événement : « GoogleRenderFromHtaccess » (en anglais)
- Action de l’événement : Rendered URL (le référent de la requête du pixel)
- Étiquette de l’événement : Une chaîne concaténant l’agent utilisateur, l’IP et si le robot est un vrai Googlebot (« Real ») ou un faux (« Fake »). J’envoie les trois à GA afin de pouvoir voir si l’identification de Googlebot fonctionne correctement.
- *Important : je n’ai stocké l’IP que pendant quelques jours afin de tester si tout fonctionnait correctement, j’ai arrêté de le faire par la suite juste au cas où il y aurait un problème avec les lois sur la protection des données.
<?php
header("Pragma-directive: no-cache");
header("Cache-directive: no-cache");
header("Cache-control: no-cache");
header("Pragma: no-cache");
header("Expires: 0");
if ($_GET["OriginUrl"])
$src=$_GET["OriginUrl"];
else
$src = $_SERVER['HTTP_REFERER'];
$UA=$_SERVER["HTTP_USER_AGENT"];
$RenderParameters=$_GET["RenderParameters"];
function GoogleCheker($Ip){
# to avoid unecessary lookup, only check if the UA matches one of
# the bots we like
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/googlebot/i",$hostname))
if ($ip_by_hostname == $Ip)
return true;
else
return false;
else
return false;
}
function GoogleChekerExtend($Ip){
# to avoid unecessary lookup, only check if the UA matches one of
# the bots we like
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/\.google\.com[\.]?$/i",$hostname))
if ($ip_by_hostname == $Ip)
return true;
else
return false;
else
return false;
}
$botname="Init";
$bots = array('Mediapartners-Google[ /]([0-9.]{1,10})' => 'Google Mediapartners',
'Mediapartners-Google' => 'Google Mediapartners',
'Googl(e|ebot)(-Image)/([0-9.]{1,10})' => 'Google Image',
'Googl(e|ebot)(-Image)/' => 'Google Image',
'^gsa-crawler' => 'Google',
'Googl(e|ebot)(-Sitemaps)/([0-9.]{1,10})?' => 'Google-Sitemaps',
'GSiteCrawler[ /v]*([0-9.a-z]{1,10})?' => 'Google-Sitemaps',
'Googl(e|ebot)(-Sitemaps)' => 'Google-Sitemaps',
'Mobile.*Googlebot' => 'Google-Mobile',
'^AdsBot-Google' => 'Google-AdsBot',
'^Feedfetcher-Google' => 'Google-Feedfetcher',
'compatible; Google Desktop' => 'Google Desktop',
'Googlebot' => 'Googlebot');
foreach( $bots as $pattern => $bot ) {
if ( preg_match( '#'.$pattern.'#i' , $UA) == 1 )
{
$botname = preg_replace ( "/\\s{1,}/i" , '-' , $bot );
break;
}
}
if(GoogleCheker($_SERVER['REMOTE_ADDR']))
$isGoogle="Real";
elseif(GoogleChekerExtend($_SERVER['REMOTE_ADDR']))
$isGoogle="Extend";
else
$isGoogle="Fake";
class BotTracker {
static function track($s, $params){
$bot = "";
$data = array(
'v' => 1,
'tid' => 'UA-XXXXXXX-1',
'cid' => self::generate_uuid(),
't' => 'event',
'dh' => $s['HTTP_HOST'],
'dl' => $s['REQUEST_URI'],
'dr' => $s['HTTP_REFERER'],
'dp' => $s['REQUEST_URI'],
'dt' => $params['page_title'],
'ck' => $s['HTTP_USER_AGENT'],
'uip' => $s['REMOTE_ADDR'],
'ni' => 1,
'ec' => 'GoogleRenderHtaccess',
'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle']."- ip: ".$s['REMOTE_ADDR'], //delete after test
//'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle'],
'ea' => $params['RenderedURL']
);
$url = 'http://www.google-analytics.com/collect';
$content = http_build_query($data);
$ch = curl_init();
curl_setopt($ch, CURLOPT_USERAGENT, $s['HTTP_USER_AGENT']);
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 0);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT_MS, 0);
curl_setopt($ch, CURLOPT_TIMEOUT_MS, 0);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-type: application/x-www-form-urlencoded'));
curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch,CURLOPT_ENCODING , "gzip");
curl_setopt($ch, CURLOPT_POSTFIELDS, $content);
$result = curl_exec($ch);
$info= curl_getinfo($ch);
curl_close($ch);
}
static private function generate_uuid() {
return sprintf( '%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff ),
mt_rand( 0, 0xffff ),
mt_rand( 0, 0x0fff ) | 0x4000,
mt_rand( 0, 0x3fff ) | 0x8000,
mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff )
);
}
}
BotTracker::track($_SERVER, array("page_title"=>"VirtualRenderTitle","RenderedURL"=>$src,"isGoogle"=>$isGoogle,"botname"=>$botname,"UA"=>$UA,"RenderParameters"=>$RenderParameters));
?>
Vérification de la configuration dans Google Analytics
Tout est configuré ! Nous pouvons maintenant vérifier si tout fonctionne comme prévu. Pour ce faire, nous pouvons utiliser le rapport en temps réel de Google Analytics et sélectionner le rapport « Events ». Dans un autre onglet, nous ouvrons la Search Console, nous allons sur la propriété de notre site Web et nous utilisons l’inspecteur d’URL pour forcer Google à explorer et à rendre n’importe laquelle de nos URLs. Si tout fonctionne, vous verrez de nouveaux événements dans le rapport des événements en temps réel de Google Analytics.
Comme vous le verrez, ces événements ne seront pas comptabilisés comme des utilisateurs actifs sur notre site, car l’événement est configuré avec le paramètre « nonInteraction ».
Si nous cliquons sur la catégorie d’événement « GoogleRenderFromHtaccess », nous pourrons voir l’agent utilisateur, l’IP et si le bot a été identifié comme réel ou faux.
Suivi des erreurs générées par Google lors du rendu d’une URL
Nous avons déjà vu comment nous pouvons suivre et vérifier quelles URLs sont rendues par Google. Mais nous pouvons aller plus loin et suivre les erreurs Javascript qui sont générées lorsque Google essaie de rendre les URLs de notre site.
Lorsque le Javascript est rendu, des erreurs peuvent être générées qui ne sont visibles que sur le navigateur de l’utilisateur (et non sur notre serveur), donc garder la trace de ces erreurs n’est pas une tâche facile.
Aujourd’hui, si nous voulons vérifier quelles erreurs Javascript sont générées lorsque Googlebot rend nos URLs, nous ne pouvons le faire qu’en utilisant l’inspecteur d’URL dans la Search Console.
- Inspectez une URL :
- Cliquez sur « Tester l’URL en direct » :
- Vérifiez s’il y a des erreurs :
Faire cela manuellement pour un grand nombre d’URLs représente beaucoup de travail, mais nous pouvons utiliser le code que je viens de vous montrer pour repérer s’il y a des erreurs Javascript lorsque Googlebot essaie de rendre nos URLs.
Exemple d’une erreur générée exprès pour vérifier si le code fonctionne :
Ajouter du code Javascript
De la même manière que nous l’avons fait dans l’exemple précédent, nous allons capturer toute erreur Javascript en utilisant cette ligne de code : « window.addEventListener('error', function(e)« .
Chaque fois qu’une erreur est générée, une fonction qui nous permettra d’enregistrer ces erreurs et de les envoyer à Google Analytics sera exécutée. Cela sera très similaire à ce que nous avons fait dans l’exemple précédent, à la différence que cette fonction ne sera exécutée que lorsqu’il y aura une erreur Javascript.
window.addEventListener('error', function(e) {
var botPattern = "googlebot|Googlebot-Mobile|Googlebot-Image|Google favicon|Mediapartners-Google";
var re = new RegExp(botPattern, 'i');
var userAgent = navigator.userAgent;
if (re.test(userAgent)) {
var client = new XMLHttpRequest();
var ErrorsURLPixel='https://www.mecagoenlos.com/TransparentPixelGooglebotError.gif?OriginUrl='+window.location.href+'&textError='+unescape(encodeURIComponent(e.message))+'&LineError='+unescape(encodeURIComponent(e.lineno.toString()))+'&UA='+unescape(encodeURIComponent(userAgent));
client.open('GET',ErrorsURLPixel);
client.setRequestHeader('Content-Type', 'text/plain;charset=UTF-8');
client.send(e);
}
});
Ce code exécutera la fonction qui chargera un autre pixel transparent (TransparentPixelGooglebotError.gif), en ajoutant comme paramètres l’URL en cours de rendu, l’erreur et l’agent utilisateur, générant une requête vers une URL comme celle-ci :
var ErrorsURLPixel='https://www.mecagoenlos.com/TransparentPixelGooglebotError.gif?OriginUrl='+window.location.href+'&textError='+unescape(encodeURIComponent(e.message))+'&LineError='+unescape(encodeURIComponent(e.lineno.toString()))+'&UA='+unescape(encodeURIComponent(userAgent));
Server config (.htaccess)
De la même manière que dans l’exemple précédent, nous allons ajouter des règles dans le .htaccess pour détecter quand le pixel est chargé et exécuter un fichier PHP :
RewriteCond %{REQUEST_URI} TransparentPixelGooglebotError.gif
RewriteRule TransparentPixelGooglebotError.gif(.*)$ https://modelode.com/GooglebotErrorRenderJS.php$1
Ainsi, chaque fois que « https://www.mecagoenlos.com/TransparentPixelGooglebotError.gif » est demandé, le fichier PHP « GooglebotErrorRenderJS.php » sera exécuté.
Fichier PHP
Ce fichier PHP vérifiera si Googlebot est réel et enverra les données à Google Analytics en utilisant un événement de la catégorie « ErreursGoogleRender », en utilisant l’URL rendue comme action de l’événement et l’erreur elle-même comme étiquette de l’événement.
<?php
header("Pragma-directive: no-cache");
header("Cache-directive: no-cache");
header("Cache-control: no-cache");
header("Pragma: no-cache");
header("Expires: 0");
if ($_GET["OriginUrl"])
$src=$_GET["OriginUrl"];
else
$src = $_SERVER['HTTP_REFERER'];
$UA=$_SERVER["HTTP_USER_AGENT"];
$RenderParameters=$_GET["RenderParameters"];
$textError=$_GET["textError"];
$lineError=$_GET["LineError"];
function GoogleCheker($Ip){
# to avoid unecessary lookup, only check if the UA matches one of
# the bots we like
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/googlebot/i",$hostname))
if ($ip_by_hostname == $Ip)
return true;
else
return false;
else
return false;
}
function GoogleChekerExtend($Ip){
# to avoid unecessary lookup, only check if the UA matches one of
# the bots we like
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/\.google\.com[\.]?$/i",$hostname))
if ($ip_by_hostname == $Ip)
return true;
else
return false;
else
return false;
}
$botname="Init";
$bots = array('Mediapartners-Google[ /]([0-9.]{1,10})' => 'Google Mediapartners',
'Mediapartners-Google' => 'Google Mediapartners',
'Googl(e|ebot)(-Image)/([0-9.]{1,10})' => 'Google Image',
'Googl(e|ebot)(-Image)/' => 'Google Image',
'^gsa-crawler' => 'Google',
'Googl(e|ebot)(-Sitemaps)/([0-9.]{1,10})?' => 'Google-Sitemaps',
'GSiteCrawler[ /v]*([0-9.a-z]{1,10})?' => 'Google-Sitemaps',
'Googl(e|ebot)(-Sitemaps)' => 'Google-Sitemaps',
'Mobile.*Googlebot' => 'Google-Mobile',
'^AdsBot-Google' => 'Google-AdsBot',
'^Feedfetcher-Google' => 'Google-Feedfetcher',
'compatible; Google Desktop' => 'Google Desktop',
'Googlebot' => 'Googlebot');
foreach( $bots as $pattern => $bot ) {
if ( preg_match( '#'.$pattern.'#i' , $UA) == 1 )
{
$botname = preg_replace ( "/\\s{1,}/i" , '-' , $bot );
break;
}
}
if(GoogleCheker($_SERVER['REMOTE_ADDR']))
$isGoogle="Real";
elseif(GoogleChekerExtend($_SERVER['REMOTE_ADDR']))
$isGoogle="Extend";
else
$isGoogle="Fake";
class BotTracker {
static function track($s, $params){
$bot = "";
$data = array(
'v' => 1,
'tid' => 'UA-XXXX-1',
'cid' => self::generate_uuid(),
't' => 'event',
'dh' => $s['HTTP_HOST'],
'dl' => $s['REQUEST_URI'],
'dr' => $s['HTTP_REFERER'],
'dp' => $s['REQUEST_URI'],
'dt' => $params['page_title'],
'ck' => $s['HTTP_USER_AGENT'],
'uip' => $s['REMOTE_ADDR'],
'ni' => 1,
'ec' => 'ErrorsGoogleRender',
'el' => $params['textError']." (line:".$params['lineError'].") - ".$params['UA']." - " .$params['botname']." - ".$params['isGoogle']."- ip: ".$s['REMOTE_ADDR'], //delete after test
//'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle'],
'ea' => $params['RenderedURL']
);
$url = 'http://www.google-analytics.com/collect';
$content = http_build_query($data);
$ch = curl_init();
curl_setopt($ch, CURLOPT_USERAGENT, $s['HTTP_USER_AGENT']);
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 0);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT_MS, 0);
curl_setopt($ch, CURLOPT_TIMEOUT_MS, 0);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-type: application/x-www-form-urlencoded'));
curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch,CURLOPT_ENCODING , "gzip");
curl_setopt($ch, CURLOPT_POSTFIELDS, $content);
$result = curl_exec($ch);
$info= curl_getinfo($ch);
curl_close($ch);
}
static private function generate_uuid() {
return sprintf( '%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff ),
mt_rand( 0, 0xffff ),
mt_rand( 0, 0x0fff ) | 0x4000,
mt_rand( 0, 0x3fff ) | 0x8000,
mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff )
);
}
}
BotTracker::track($_SERVER, array("page_title"=>"VirtualRenderTitle","RenderedURL"=>$src,"isGoogle"=>$isGoogle,"botname"=>$botname,"UA"=>$UA,"RenderParameters"=>$RenderParameters,"textError"=>$textError,"lineError"=>$lineError));
?>
Maintenant, nous pouvons déjà voir quelles erreurs Javascript se produisent lorsque Google essaie de rendre nos URLs.
Envoyer des données à Google Analytics depuis notre fichier PHP
Avec cette implémentation, nous pouvons voir quelles erreurs Javascript spécifiques sont générées lorsque Google essaie de rendre nos URLs, et dans quelles URLs spécifiques elles se produisent.
J’ai en tête beaucoup d’autres informations à suivre concernant le processus de rendu de Google, comme vérifier si Googlebot tente certaines interactions (comme un scroll, un clic ou tout autre événement Javascript), mais je garderai cela pour un autre article. J’espère que vous l’avez aimé !
