Come visualizzare gli URL resi da Google in Google Analytics
Pubblicato: 2021-06-11Prima di tutto, un ringraziamento speciale a Christian per avermi aiutato con la traduzione!
Sono passati diversi anni da quando Google ha iniziato a fare enormi miglioramenti nella sua capacità di eseguire la scansione e caricare il contenuto con Javascript nello stesso modo in cui lo vedrebbe un vero utente con un telefono cellulare.
Tuttavia, Google non sarà in grado di eseguire la scansione di tutti gli URL che trova anche se migliora la propria infrastruttura, poiché il costo della scansione e del rendering (il processo di trasformazione di un documento HTML in una struttura visiva) è enormemente maggiore della semplice scansione e ottenere l'HTML di un URL. Google stesso lo ha riconosciuto, quindi è importante assicurarsi che Google trovi, visualizzi e indicizzi gli URL più importanti del nostro sito, specialmente nei siti più grandi e/o nei siti che dipendono dall'esecuzione di JS da parte del client (CSR, Client Side Rendering)
Anni fa, per valutare il contenuto di un URL e decidere se aggiungerlo o meno all'indice, Google ne aveva abbastanza di ottenere l'HTML dell'URL (così come le immagini lì collegate). Quell'HTML era il contenuto utilizzato da Google per indicizzare e classificare l'URL, senza tener conto se quell'HTML è stato modificato utilizzando Javascript dopo il rendering o meno.
Ora, con il clamore dei framework Javascript che modificano l'HTML lato client, Google ha bisogno di ottenere l'HTML, il codice JS, gli stili CSS e altre risorse (come immagini, fronti, ecc.) per rendere il contenuto e ottenere l'HTML finale, in modo che possa decidere se andare all'indice o meno.
L'intero processo non viene eseguito in un batch come vedrebbe un utente normale: viene eseguito in due passaggi. Innanzitutto, Google esegue la scansione dell'URL e ottiene l'HTML "non renderizzato" (come è stato fatto fino ad ora), e poco dopo (senza un determinato periodo di tempo), ottiene il resto delle risorse a cui si fa riferimento in quell'HTML e prova per eseguire il rendering della pagina per ottenere l'HTML finale visualizzato. Questo secondo passaggio è denominato "seconda ondata di indicizzazione".
Non è necessario disporre di molte conoscenze tecniche per capire che, per eseguire la scansione e l'indicizzazione di un certo numero di URL, il costo del rendering degli stessi è molto maggiore del semplice ottenere l'HTML non renderizzato, sia in termini di tempo che di risorse. Pertanto, utilizzando la stessa quantità di risorse limitate, Google sarà in grado di eseguire la scansione e indicizzare meno URL se è necessario renderli. Ecco perché Google deve decidere/dare priorità a quali URL visualizzare e quali no.
Per decidere quale URL deve essere scansionato successivamente, Google calcola la probabilità che quell'URL sia cambiato dall'ultima volta che è stato scansionato, tenendo conto di altri fattori come il PageRank di ciascun URL o se il webmaster ha configurato un'impostazione specifica per quanto riguarda la scansione frequenza. Questo ha senso in quanto è inutile spendere risorse limitate per eseguire la scansione di qualcosa che non è cambiato.
Vorrei condividere questo articolo con te perché penso che non sia molto noto e può essere molto rivelatore per capire come Google decide quale URL scansionare dopo. È scritto dagli ingegneri di Google ed è un'astrazione matematica per risolvere un problema reale. Non spaventarti con le formule matematiche, è perfettamente spiegato per le persone che non sono Data Scientist.
Dopo aver deciso quale URL scansionare successivamente, Googlebot deve decidere, per ogni URL scansionato, se deve visualizzare o meno quell'URL e, se decide di eseguire il rendering di un URL, avrà bisogno di tutte le risorse per farlo. Per decidere se è necessario richiedere ciascuna delle risorse necessarie, probabilmente utilizza un processo matematico simile ma con alcune differenze come i tempi di cache, il costo per ottenere la risorsa, ecc.
A causa di tutto ciò, è molto importante sapere quali URL del nostro sito vengono scansionati da Google e anche quali vengono visualizzati. Un modo semplice per ottenere queste informazioni, che utilizziamo in Funnel▼Punk (dove lavoriamo con grandi siti Web), è analizzare i log del server (ecco un post al riguardo nel mio blog, in spagnolo, e un altro sul blog di Oncrawl ), ottenendo un quadro completo di ciò che Googlebot sta facendo nel nostro sito. L'analisi dei log può essere noiosa e costosa per molte persone, ecco perché vorrei condividere con te un modo per monitorare quali URL vengono visualizzati da Googlebot in Google Analytics.
[Case Study] Gestione della scansione dei bot di Google
Leggi il caso di studioURL di monitoraggio resi da Google
Il metodo è relativamente semplice, almeno per qualsiasi team di sviluppo e per qualsiasi webmaster abituato a lavorare con PHP o simili. Ha 3 passaggi:
- Aggiungi codice javascript
Il codice rileverà quando Googlebot ha eseguito Javascript allo stesso modo di un normale utente e caricherà un'immagine utilizzando Javascript (un pixel trasparente). - Configurazione server
Configura il server per eseguire un file PHP (o qualsiasi altro linguaggio di programmazione utilizzato nel backend) quando viene richiesto l'URL del pixel trasparente. - Invia i dati a Google Analytics
Il nostro file PHP verificherà se Googlebot è davvero Googlebot e, in tal caso, invierà i dati a Google Analytics.
Aggiungi codice javascript
In diversi esperimenti che ho provato, ho verificato che Googlebot esegua Javascript solo quando il codice Javascript non richiede l'interazione dell'utente. Ad esempio, Googlebot eseguirà qualsiasi codice Javascript attivato con gli eventi onload o onready. In questo esempio creeremo una funzione che verrà attivata con l'evento onLoad, ovvero quando tutti gli elementi della pagina verranno caricati.
Questa funzione verificherà se lo User Agent contiene uno dei bot conosciuti di Googlebot e, in tal caso, caricherà un'immagine (un pixel trasparente), che chiameremo TransparentPixelGooglebot.gif
<script>
window.addEventListener("carica", funzione(){
var botPattern = "googlebot|Googlebot-Mobile|Googlebot-Image|Google favicon|Mediapartners-Google";
var re = new RegExp(botPattern, 'i');
var userAgent = navigator.userAgent;
se (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> Ogni volta che Googlebot accede ed esegue Javascript, la nostra funzione verrà attivata, caricando l'immagine “TransparentPixelGooglebot.gif”, aggiungendo all'URL dell'immagine alcuni parametri dove specificheremo l'URL specifico a cui è stato effettuato l'accesso.In questa variabile comporremo l'URL completo che verrà richiesto per caricare la nostra immagine "TransparentPixelGooglebot.gif", dove aggiungeremo l'URL a cui si accede e lo User Agent che lo richiede.
var trackRenderURL='https://www.mecagoenlos.com/TransparentPixelGooglebot.gif?OriginUrl='+window.location.href;
Configurazione del server (.htaccess)
Il nostro prossimo passo è configurare il nostro server in modo che ogni volta che viene richiesto l'URL del pixel (TransparentPixelGooglebot.gif), venga eseguito un file PHP (GooglebotRenderJS.php)
Per fare ciò, dobbiamo apportare alcune modifiche al nostro file .htaccess (dato che stiamo usando un server Apache e PHP come linguaggio di programmazione back-end)
Queste due linee specifiche sono quelle che lo faranno accadere:
RewriteCond %{REQUEST_URI} TransparentPixelGooglebot.gif
RewriteRule TransparentPixelGooglebot.gif(.*)$ https://www.mecagoenlos.com.com/GooglebotRenderJS.php$1Come si può intuire, i parametri inclusi nella richiesta di pixel vengono propagati in modo che il file PHP (GooglebotRenderJS.php) possa “leggerli”.
Scansione dati³
Per saperne di piùInvia i dati a Google Analytics dal file PHP
Nel nostro ultimo passaggio, creiamo il file PHP (GooglebotRenderJS.php) che verrà eseguito ogni volta che verrà richiesto il pixel (TransparentPixelGooglebot.gif).
Questo file:
- Verifica, utilizzando il DNS inverso, se la richiesta è stata effettivamente effettuata da Googlebot o da un falso Googlebot utilizzando lo User Agent di Googlebot
- Identifica di che tipo di bot si tratta (Googlebot Mobile, Immagini, Annunci, ecc.)
- Invia i dati a Google Analytics (utilizzando il protocollo di misurazione di Google Analytics) all'interno di un evento a cui assegneremo le seguenti variabili:
- Categoria evento: "GoogleRenderFromHtaccess"
- Azione evento: URL visualizzato (il referrer della richiesta pixel)
- Etichetta evento: una stringa che concatena l'agente utente, l'IP e se il bot è un vero Googlebot ("Real") o uno falso ("Fake"). Li mando tutti e tre a GA per poter vedere se l'identificazione di Googlebot funziona correttamente.
- *Importante: ho memorizzato l'IP solo per un paio di giorni per verificare se tutto funzionava correttamente, ho smesso di farlo in seguito nel caso ci fossero problemi con le leggi sulla protezione dei dati
<?php
header("Direttiva Pragma: no-cache");
header("Direttiva cache: no-cache");
header("Cache-control: no-cache");
header("Pragma: no-cache");
header("Scade: 0");
se ($_GET["OriginUrl"])
$src=$_GET["URL di origine"];
altro
$src = $_SERVER['HTTP_REFERER'];
$UA=$_SERVER["AGENTE_UTENTE_HTTP"];
$RenderParameters=$_GET["RenderParameters"];
funzione GoogleCheker($Ip){
# per evitare ricerche inutili, controlla solo se l'UA corrisponde a uno di
# i bot che ci piacciono
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/googlebot/i",$nomehost))
se ($ip_by_hostname == $IP)
restituisce vero;
altro
restituire falso;
altro
restituire falso;
}
funzione GoogleChekerExtend($Ip){
# per evitare ricerche inutili, controlla solo se l'UA corrisponde a uno di
# i bot che ci piacciono
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/\.google\.com[\.]?$/i",$nomehost))
se ($ip_by_hostname == $IP)
restituisce vero;
altro
restituire falso;
altro
restituire falso;
}
$botname="Inizia";
$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-Sitemap',
'GSiteCrawler[ /v]*([0-9.az]{1,10})?' => 'Google-Sitemap',
'Googl(e|ebot)(-Sitemaps)' => 'Google-Sitemaps',
'Mobile.*Googlebot' => 'Google-Mobile',
'^AdsBot-Google' => 'Google-AdsBot',
'^Feedfetcher-Google' => 'Google-Feedfetcher',
'compatibile; Google Desktop' => 'Google Desktop',
'Googlebot' => 'Googlebot');
foreach($bot come $modello => $bot) {
if ( preg_match( '#'.$pattern.'#i' , $UA) == 1 )
{
$botname = preg_replace ("/\\s{1,}/i" , '-' , $bot );
rompere;
}
}
se(GoogleCheker($_SERVER['REMOTE_ADDR'])))
$isGoogle="Reale";
elseif(GoogleChekerExtend($_SERVER['REMOTE_ADDR'])))
$isGoogle="Estendi";
altro
$isGoogle="falso";
classe BotTracker {
traccia funzione statica($s, $params){
$bot = "";
$dati = matrice(
'v' => 1,
'tid' => 'UA-XXXXXXX-1',
'cid' => self::generate_uuid(),
't' => 'evento',
'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'], //elimina dopo il test
//'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle'] ,
'ea' => $params['RenderedURL']
);
$url = 'http://www.google-analytics.com/collect';
$contenuto = http_build_query($dati);
$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);
$risultato = curl_exec($ch);
$info= curl_getinfo($ch);
curl_close($ch);
}
funzione privata statica generate_uuid() {
ritorno 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));
?>
Controlla se la nostra configurazione funziona in Google Analytics
Tutto è pronto! Ora possiamo verificare se tutto funziona come previsto. Per farlo, possiamo utilizzare il rapporto in tempo reale di Google Analytics e selezionare il rapporto "Eventi". In un'altra scheda, apriamo Search Console, andiamo alla proprietà del nostro sito Web e utilizziamo Controllo URL per forzare Google a eseguire la scansione e il rendering di qualsiasi nostro URL. Se tutto funziona, vedrai nuovi eventi nel rapporto sugli eventi in tempo reale di Google Analytics.
Come vedrai, questi eventi non verranno conteggiati come utenti attivi nel nostro sito, perché l'evento è configurato con il parametro “nonInteraction”.
Se clicchiamo sulla categoria dell'evento “GoogleRenderFromHtaccess”, potremo vedere lo User Agent, l'IP e se il bot è stato identificato come Reale o Falso.
Errori di tracciamento generati da Google che tenta di eseguire il rendering di un URL
Abbiamo già visto come possiamo tracciare e controllare quali URL vengono visualizzati da Google. Ma possiamo andare oltre e monitorare quali errori Javascript vengono generati quando Google tenta di visualizzare gli URL del nostro sito.
Quando viene eseguito il rendering di Javascript, possono essere generati errori visibili solo sul browser dell'utente (e non sul nostro server), quindi tenere traccia di tali errori non è un compito facile.
Al giorno d'oggi, se vogliamo controllare quali errori Javascript vengono generati quando Googlebot esegue il rendering dei nostri URL, possiamo farlo solo utilizzando URL Inspector in Search Console
- Ispeziona un URL:
- Fare clic su "Verifica URL in tempo reale":
- Controlla se ci sono errori:
Farlo manualmente per molti URL richiede molto lavoro, ma possiamo utilizzare il codice che ti ho appena mostrato per tenere traccia di eventuali errori Javascript quando Googlebot tenta di eseguire il rendering dei nostri URL.
Esempio di errore generato apposta per verificare se il codice funziona:
Aggiungi codice Javascript
Allo stesso modo dell'esempio precedente, cattureremo qualsiasi errore Javascript utilizzando questa riga di codice: "window.addEventListener('error', function(e)" .
Ogni volta che viene generato un errore, verrà eseguita una funzione che ci consentirà di salvare tali errori e inviarli a Google Analytics. Questo sarà molto simile a quello che abbiamo fatto nell'esempio precedente con l'avvertenza che questa funzione verrà eseguita solo quando si verifica un errore Javascript.
window.addEventListener('errore', funzione(e) {
var botPattern = "googlebot|Googlebot-Mobile|Googlebot-Image|Google favicon|Mediapartners-Google";
var re = new RegExp(botPattern, 'i');
var userAgent = navigator.userAgent;
se (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);
}
});
Questo codice eseguirà la funzione che caricherà un altro pixel trasparente (TransparentPixelGooglebotError.gif), aggiungendo come parametri l'URL in fase di rendering, l'errore e lo User Agent, generando una richiesta ad un URL come questo:
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));
Configurazione del server (.htaccess)
Come nell'esempio precedente, aggiungeremo alcune regole in .htaccess per rilevare quando il pixel viene caricato ed eseguire un file PHP:
RewriteCond %{REQUEST_URI} TransparentPixelGooglebotError.gif
RewriteRule TransparentPixelGooglebotError.gif(.*)$ https://modelode.com/GooglebotErrorRenderJS.php$1 In questo modo, ogni volta che viene richiesto "https://www.mecagoenlos.com/TransparentPixelGooglebotError.gif", verrà eseguito il file PHP "GooglebotErrorRenderJS.php".
File PHP
Questo file PHP verificherà se Googlebot è reale e invierà i dati a Google Analytics utilizzando un evento con la categoria "ErrorsGoogleRender", utilizzando l'URL visualizzato come Azione dell'evento e l'errore stesso come etichetta dell'evento.
<?php
header("Direttiva Pragma: no-cache");
header("Direttiva cache: no-cache");
header("Cache-control: no-cache");
header("Pragma: no-cache");
header("Scade: 0");
se ($_GET["OriginUrl"])
$src=$_GET["URL di origine"];
altro
$src = $_SERVER['HTTP_REFERER'];
$UA=$_SERVER["AGENTE_UTENTE_HTTP"];
$RenderParameters=$_GET["RenderParameters"];
$textError=$_GET["textError"];
$lineError=$_GET["LineError"];
funzione GoogleCheker($Ip){
# per evitare ricerche inutili, controlla solo se l'UA corrisponde a uno di
# i bot che ci piacciono
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/googlebot/i",$nomehost))
se ($ip_by_hostname == $IP)
restituisce vero;
altro
restituire falso;
altro
restituire falso;
}
funzione GoogleChekerExtend($Ip){
# per evitare ricerche inutili, controlla solo se l'UA corrisponde a uno di
# i bot che ci piacciono
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/\.google\.com[\.]?$/i",$nomehost))
se ($ip_by_hostname == $IP)
restituisce vero;
altro
restituire falso;
altro
restituire falso;
}
$botname="Inizia";
$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-Sitemap',
'GSiteCrawler[ /v]*([0-9.az]{1,10})?' => 'Google-Sitemap',
'Googl(e|ebot)(-Sitemaps)' => 'Google-Sitemaps',
'Mobile.*Googlebot' => 'Google-Mobile',
'^AdsBot-Google' => 'Google-AdsBot',
'^Feedfetcher-Google' => 'Google-Feedfetcher',
'compatibile; Google Desktop' => 'Google Desktop',
'Googlebot' => 'Googlebot');
foreach($bot come $modello => $bot) {
if ( preg_match( '#'.$pattern.'#i' , $UA) == 1 )
{
$botname = preg_replace ("/\\s{1,}/i" , '-' , $bot );
rompere;
}
}
se(GoogleCheker($_SERVER['REMOTE_ADDR'])))
$isGoogle="Reale";
elseif(GoogleChekerExtend($_SERVER['REMOTE_ADDR'])))
$isGoogle="Estendi";
altro
$isGoogle="falso";
classe BotTracker {
traccia funzione statica($s, $params){
$bot = "";
$dati = matrice(
'v' => 1,
'tid' => 'UA-XXXX-1',
'cid' => self::generate_uuid(),
't' => 'evento',
'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' => 'ErroriGoogleRender',
'el' => $params['textError']." (line:".$params['lineError'].") - ".$params['UA']." - " .$params['botname' ]." - ".$params['isGoogle']."- ip: ".$s['REMOTE_ADDR'], //elimina dopo il test
//'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle'] ,
'ea' => $params['RenderedURL']
);
$url = 'http://www.google-analytics.com/collect';
$contenuto = http_build_query($dati);
$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);
$risultato = curl_exec($ch);
$info= curl_getinfo($ch);
curl_close($ch);
}
funzione privata statica generate_uuid() {
ritorno 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));
?>
Ora possiamo già vedere quali errori Javascript si verificano quando Google tenta di eseguire il rendering dei nostri URL.
Invia i dati a Google Analytics dal nostro file PHP
Con questa implementazione, possiamo vedere quali specifici errori Javascript vengono generati quando Google tenta di eseguire il rendering dei nostri URL e in quali URL specifici si verificano.
Ho in mente molte altre informazioni da tracciare riguardo al processo di rendering di Google, come controllare se Googlebot sta provando alcune interazioni (come scorrere, un clic o qualsiasi altro evento Javascript), ma lo terrò in un altro post. Spero ti sia piaciuto!