Cum să vizualizați adresele URL redate de Google în Google Analytics
Publicat: 2021-06-11În primul rând, îi mulțumesc special lui Christian pentru că m-a ajutat cu traducerea!
Au trecut câțiva ani de când Google a început să facă îmbunătățiri uriașe în capacitatea sa de a accesa cu crawlere și de a încărca conținutul cu Javascript în același mod în care un utilizator real cu un telefon mobil l-ar vedea.
Cu toate acestea, Google nu va putea accesa cu crawlere toate adresele URL pe care le găsește, chiar dacă își îmbunătățește infrastructura, deoarece costul accesării cu crawlere și redării (procesul de transformare a unui document HTML într-o structură vizuală) este mult mai mare decât simpla accesare cu crawlere și obținere. HTML-ul unei adrese URL. Google însuși a recunoscut acest lucru, așa că este important să ne asigurăm că Google va găsi, reda și indexa cele mai importante adrese URL ale site-ului nostru, în special pe site-uri mai mari și/sau site-uri care depind de executarea JS de către client (CSR, Client Side Rendering)
Cu ani în urmă, pentru a aprecia conținutul unei adrese URL și a decide dacă să-l adauge sau nu la index, Google s-a săturat să obțină HTML-ul URL-ului (precum și imaginile legate acolo). Acel HTML a fost conținutul pe care Google l-a folosit pentru a indexa și a clasifica adresa URL, fără a lua în considerare dacă acel HTML a fost modificat folosind Javascript după randare sau nu.
Acum, cu hype-ul cadrelor Javascript care modifică partea clientului HTML, Google trebuie să obțină HTML, codul JS, stilurile CSS și alte resurse (cum ar fi imagini, fronturi etc.) pentru a reda conținutul și a obține HTML final, astfel încât să poată decide dacă merge la index sau nu.
Întregul proces nu se face într-un singur lot, așa cum ar vedea un utilizator normal: se face în doi pași. În primul rând, Google accesează cu crawlere adresa URL și primește codul HTML „neredat” (așa cum a procedat până acum), iar după un timp (fără o perioadă de timp specificată), primește restul resurselor la care se face referire în acel HTML și încearcă pentru a randa pagina pentru a obține HTML-ul final, redat. Acest al doilea pas este denumit „al doilea val de indexare”.
Nu trebuie să avem multe cunoștințe tehnice pentru a înțelege că, pentru a accesa cu crawlere și a indexa un număr de adrese URL, costul redării lor este mult mai mare decât obținerea HTML neredat, atât în timp, cât și în resurse. Deci, folosind aceeași cantitate de resurse finite, Google va putea să acceseze cu crawlere și să indexeze mai puține adrese URL dacă va trebui să le redea. De aceea, Google trebuie să decidă/să acorde prioritate ce adrese URL să redeze și care nu.
Pentru a decide ce adresă URL ar trebui accesată cu crawlere, Google calculează probabilitatea ca acea adresă URL să se fi modificat de la ultima dată când a fost accesată cu crawlere, ținând cont de alți factori precum PageRank-ul fiecărei adrese URL sau dacă webmasterul a configurat vreo setare specifică privind accesarea cu crawlere. frecvență. Acest lucru are sens, deoarece este inutil să cheltuiți resurse limitate pentru a accesa cu crawlere ceva care nu s-a schimbat.
Aș dori să vă împărtășesc acest articol, deoarece cred că nu este foarte cunoscut și poate fi foarte revelator pentru a înțelege cum decide Google ce adresă URL să acceseze cu crawlere. Este scris de inginerii Google și este o abstractizare matematică pentru a rezolva o problemă reală. Nu vă speriați cu formulele matematice, este perfect explicat pentru oamenii care nu sunt Data Scientists.
După ce a decis ce adresă URL să acceseze cu crawlere, Googlebot trebuie să decidă, pentru fiecare adresă URL accesată cu crawlere, dacă ar trebui să redea respectiva adresă URL sau nu și, dacă decide să redea o adresă URL, va avea nevoie de toate resursele pentru a realiza acest lucru. Pentru a decide dacă trebuie să solicite fiecare dintre resursele necesare, probabil că utilizează un proces matematic similar, dar cu unele diferențe precum timpii de cache, costul obținerii resursei etc.
Din cauza tuturor acestor lucruri, este foarte important să știm care adrese URL de pe site-ul nostru sunt accesate cu crawlere de Google și, de asemenea, care sunt redate. O modalitate ușoară de a obține aceste informații, pe care o folosim la Funnel▼Punk (unde lucrăm cu site-uri web mari), este prin analiza jurnalelor de server (iată o postare despre asta pe blogul meu, în spaniolă, și alta pe blogul Oncrawl). ), obținând o imagine completă a ceea ce face Googlebot pe site-ul nostru. Analiza jurnalelor poate fi plictisitoare și costisitoare pentru mulți oameni, de aceea aș dori să vă împărtășesc o modalitate de a urmări ce adrese URL sunt redate de Googlebot în Google Analytics.
[Studiu de caz] Gestionarea accesării cu crawlere a botului Google
Citiți studiul de cazUrmărirea adreselor URL redate de Google
Metoda este relativ simplă, cel puțin pentru orice echipă de dezvoltatori și pentru orice webmaster obișnuit să lucreze cu PHP sau similar. Are 3 pași:
- Adăugați codul javascript
Codul va detecta când Googlebot a executat Javascript la fel ca un utilizator normal și va încărca o imagine folosind Javascript (un pixel transparent). - Configurare server
Configurați serverul să execute un fișier PHP (sau orice alt limbaj de programare folosit în backend) atunci când este solicitată adresa URL a pixelului transparent. - Trimiteți datele către Google Analytics
Fișierul nostru PHP va verifica dacă Googlebot este cu adevărat Googlebot și, dacă da, va trimite datele către Google Analytics.
Adăugați codul javascript
În diferite experimente pe care le-am încercat, am verificat că Googlebot va executa Javascript numai atunci când codul Javascript nu are nevoie de interacțiunea utilizatorului. De exemplu, Googlebot va executa orice cod Javascript care este declanșat cu evenimentele onload sau onready. În acest exemplu, vom crea o funcție care va fi declanșată cu evenimentul onLoad, adică atunci când toate elementele paginii sunt încărcate.
Această funcție va verifica dacă User Agent conține vreunul dintre roboții cunoscuți ai Googlebot și, dacă da, va încărca o imagine (un pixel transparent), pe care o vom numi TransparentPixelGooglebot.gif
<script>
window.addEventListener(„încărcare”, funcția(){
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> Ori de câte ori Googlebot accesează și execută Javascript, funcția noastră va fi declanșată, încărcând imaginea „TransparentPixelGooglebot.gif”, adăugând la adresa URL a imaginii câțiva parametri în care vom specifica adresa URL specifică care a fost accesată.În această variabilă vom compune adresa URL completă care va fi solicitată pentru a încărca imaginea noastră „TransparentPixelGooglebot.gif”, unde adăugăm URL-ul accesat, precum și Agentul utilizator care o solicită.
var trackRenderURL='https://www.mecagoenlos.com/TransparentPixelGooglebot.gif?OriginUrl='+window.location.href;
Configurare server (.htaccess)
Următorul pas este să ne configuram serverul astfel încât oricând adresa URL a pixelului (TransparentPixelGooglebot.gif) este solicitată, să fie executat un fișier PHP (GooglebotRenderJS.php)
Pentru a face acest lucru, trebuie să facem câteva modificări în fișierul nostru .htaccess (deoarece folosim un server Apache și PHP ca limbaj de programare backend)
Aceste două linii specifice sunt cele care vor face acest lucru să se întâmple:
RewriteCond %{REQUEST_URI} TransparentPixelGooglebot.gif
RewriteRule TransparentPixelGooglebot.gif(.*)$ https://www.mecagoenlos.com.com/GooglebotRenderJS.php$1După cum puteți ghici, parametrii incluși în cererea de pixeli sunt propagați astfel încât fișierul PHP (GooglebotRenderJS.php) să îi poată „citi”.
Date oncrawl³
Află mai multeTrimiteți datele către Google Analytics din fișierul PHP
În ultimul pas, creăm fișierul PHP (GooglebotRenderJS.php) care va fi executat oricând este solicitat pixelul (TransparentPixelGooglebot.gif).
Acest fișier va:
- Verificați, folosind DNS invers, dacă solicitarea a fost făcută de fapt de Googlebot sau de un Googlebot fals folosind Agentul de utilizator al Googlebot
- Identificați ce tip de bot este (Googlebot mobil, imagini, anunțuri etc.)
- Trimiteți datele către Google Analytics (folosind protocolul de măsurare Google Analytics) în cadrul unui eveniment la care vom atribui următoarele variabile:
- Categoria evenimentului: „GoogleRenderFromHtaccess”
- Acțiunea evenimentului: Adresa URL redată (referitorul solicitării de pixeli)
- Eticheta evenimentului: un șir care concatenează agentul utilizator, IP-ul și dacă botul este Googlebot real („Real”) sau unul fals („Fake”). Le trimit pe cei trei la GA pentru a putea vedea dacă identificarea Googlebot funcționează corect.
- *Important: am stocat IP-ul doar câteva zile pentru a testa dacă totul mergea corect, am încetat să mai fac asta după aceea în cazul în care există vreo problemă cu legile privind protecția datelor
<?php
header("Directiva Pragma: fără cache");
header("Directiva cache: fără cache");
header("Controlul cache: fără cache");
header("Pragma: fără cache");
antet ("Expiră: 0");
dacă ($_GET["OriginUrl"])
$src=$_GET["OriginUrl"];
altfel
$src = $_SERVER['HTTP_REFERER'];
$UA=$_SERVER[„HTTP_USER_AGENT”];
$RenderParameters=$_GET["RenderParameters"];
funcția GoogleCheker($Ip){
# pentru a evita căutările inutile, verificați doar dacă UA se potrivește cu una dintre
# roboții care ne plac
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($nume gazdă);
if(preg_match("/googlebot/i",$hostname))
if ($ip_by_hostname == $Ip)
returnează adevărat;
altfel
returnează fals;
altfel
returnează fals;
}
funcția GoogleChekerExtend($Ip){
# pentru a evita căutările inutile, verificați doar dacă UA se potrivește cu una dintre
# roboții care ne plac
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($nume gazdă);
if(preg_match("/\.google\.com[\.]?$/i",$hostname))
if ($ip_by_hostname == $Ip)
returnează adevărat;
altfel
returnează fals;
altfel
returnează fals;
}
$botname="Init";
$bots = array('Mediapartners-Google[ /]([0-9.]{1,10})' => 'Google Mediapartners',
'Mediapartners-Google' => 'Google Mediapartners',
„Googl(e|ebot)(-Image)/([0-9.]{1,10})” => „Imagine Google”,
„Googl(e|ebot)(-Image)/” => „Imagine Google”,
'^gsa-crawler' => 'Google',
„Googl(e|ebot)(-Sitemaps)/([0-9.]{1,10})?” => 'Google-Sitemaps',
„GSiteCrawler[ /v]*([0-9.az]{1,10})?” => 'Google-Sitemaps',
„Googl(e|ebot)(-Sitemaps)” => „Google-Sitemaps”,
'Mobile.*Googlebot' => 'Google-Mobile',
'^AdsBot-Google' => 'Google-AdsBot',
'^Feedfetcher-Google' => 'Google-Feedfetcher',
'compatibil; Google Desktop' => 'Google Desktop',
'Googlebot' => 'Googlebot');
foreach( $bots ca $pattern => $bot ) {
if (preg_match( '#'.$pattern.'#i' , $UA) == 1)
{
$botname = preg_replace ( "/\\s{1,}/i" , '-' , $bot );
pauză;
}
}
if(GoogleCheker($_SERVER['REMOTE_ADDR']))
$isGoogle="Real";
elseif(GoogleChekerExtend($_SERVER['REMOTE_ADDR']))
$isGoogle="Extend";
altfel
$isGoogle="Fake";
clasa BotTracker {
track function static($s, $params){
$bot = "";
$date = matrice(
'v' => 1,
'tid' => 'UA-XXXXXXX-1',
'cid' => self::generate_uuid(),
't' => 'eveniment',
'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'], //șterge după test
//'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle'] ,
'ea' => $params['RenderedURL']
);
$url = „http://www.google-analytics.com/collect”;
$conținut = http_build_query($date);
$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, $conținut);
$rezultat = curl_exec($ch);
$info= curl_getinfo($ch);
curl_close($ch);
}
funcție privată statică generate_uuid() {
returnează 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));
?>
Verificați dacă configurația noastră funcționează în Google Analytics
Totul este pus la punct! Acum putem verifica dacă totul funcționează conform așteptărilor. Pentru a face acest lucru, putem folosi raportul în timp real din Google Analytics și selectați raportul „Evenimente”. Într-o altă filă, deschidem Search Console, mergem la proprietatea site-ului nostru și folosim Inspectorul URL pentru a forța Google să acceseze cu crawlere și să redeze oricare dintre adresele noastre URL. Dacă totul funcționează, veți vedea evenimente noi în raportul de evenimente în timp real Google Analytics.
După cum veți vedea, aceste evenimente nu vor fi considerate utilizatori activi pe site-ul nostru, deoarece evenimentul este configurat cu parametrul „nonInteraction”.
Dacă facem clic pe categoria de eveniment „GoogleRenderFromHtaccess”, vom putea vedea User Agent, IP-ul și dacă botul a fost identificat ca Real sau Fals.
Erori de urmărire generate de Google care încearcă să redeze o adresă URL
Am văzut deja cum putem urmări și verifica ce adrese URL sunt redate de Google. Dar putem merge mai departe și urmărim ce erori Javascript sunt generate atunci când Google încearcă să redeze adrese URL ale site-ului nostru.
Când Javascript este redat, pot fi generate erori care sunt vizibile doar în browserul utilizatorului (și nu pe serverul nostru), așa că urmărirea acestor erori nu este o sarcină ușoară.
În zilele noastre, dacă vrem să verificăm ce erori Javascript sunt generate atunci când Googlebot redă adresele URL, o putem face doar folosind Inspectorul URL din Search Console
- Inspectați o adresă URL:
- Faceți clic pe „Testează URL live”:
- Verificați dacă există erori:
A face acest lucru manual pentru o mulțime de adrese URL este multă muncă, dar putem folosi codul pe care tocmai ți l-am arătat pentru a urmări dacă există erori de JavaScript atunci când Googlebot încearcă să ne redeze adresele URL.
Exemplu de eroare generată intenționat pentru a verifica dacă codul funcționează:
Adăugați cod Javascript
Așa cum am procedat în exemplul anterior, vom captura orice eroare Javascript folosind această linie de cod: "window.addEventListener('error', function(e)" .
Ori de câte ori este generată o eroare, se va executa o funcție care ne va permite să salvăm acele erori și să le trimitem la Google Analytics. Acest lucru va fi foarte asemănător cu ceea ce am făcut în exemplul anterior, cu avertismentul că această funcție va fi executată numai atunci când există o eroare Javascript.
window.addEventListener('eroare', 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',EroriURLPixel);
client.setRequestHeader('Content-Type', 'text/plain;charset=UTF-8');
client.send(e);
}
});
Acest cod va executa funcția care va încărca un alt pixel transparent (TransparentPixelGooglebotError.gif), adăugând ca parametri URL-ul redat, eroarea și User Agent, generând o solicitare la o adresă URL ca aceasta:
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));
Configurare server (.htaccess)
La fel ca în exemplul anterior, vom adăuga câteva reguli în .htaccess pentru a detecta când pixelul este încărcat și pentru a executa un fișier PHP:
RewriteCond %{REQUEST_URI} TransparentPixelGooglebotError.gif
RewriteRule TransparentPixelGooglebotError.gif(.*)$ https://modelode.com/GooglebotErrorRenderJS.php$1 În acest fel, ori de câte ori este solicitat „https://www.mecagoenlos.com/TransparentPixelGooglebotError.gif”, fișierul PHP „GooglebotErrorRenderJS.php” va fi executat.
Fișier PHP
Acest fișier PHP va verifica dacă Googlebot este real și va trimite datele către Google Analytics folosind un eveniment cu categoria „ErrorsGoogleRender”, folosind adresa URL redată ca acțiune pentru eveniment și eroarea în sine ca etichetă de eveniment.
<?php
header("Directiva Pragma: fără cache");
header("Directiva cache: fără cache");
header("Controlul cache: fără cache");
header("Pragma: fără cache");
antet ("Expiră: 0");
dacă ($_GET["OriginUrl"])
$src=$_GET["OriginUrl"];
altfel
$src = $_SERVER['HTTP_REFERER'];
$UA=$_SERVER[„HTTP_USER_AGENT”];
$RenderParameters=$_GET["RenderParameters"];
$textError=$_GET["textError"];
$lineError=$_GET["LineError"];
funcția GoogleCheker($Ip){
# pentru a evita căutările inutile, verificați doar dacă UA se potrivește cu una dintre
# roboții care ne plac
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($nume gazdă);
if(preg_match("/googlebot/i",$hostname))
if ($ip_by_hostname == $Ip)
returnează adevărat;
altfel
returnează fals;
altfel
returnează fals;
}
funcția GoogleChekerExtend($Ip){
# pentru a evita căutările inutile, verificați doar dacă UA se potrivește cu una dintre
# roboții care ne plac
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($nume gazdă);
if(preg_match("/\.google\.com[\.]?$/i",$hostname))
if ($ip_by_hostname == $Ip)
returnează adevărat;
altfel
returnează fals;
altfel
returnează fals;
}
$botname="Init";
$bots = array('Mediapartners-Google[ /]([0-9.]{1,10})' => 'Google Mediapartners',
'Mediapartners-Google' => 'Google Mediapartners',
„Googl(e|ebot)(-Image)/([0-9.]{1,10})” => „Imagine Google”,
„Googl(e|ebot)(-Image)/” => „Imagine Google”,
'^gsa-crawler' => 'Google',
„Googl(e|ebot)(-Sitemaps)/([0-9.]{1,10})?” => 'Google-Sitemaps',
„GSiteCrawler[ /v]*([0-9.az]{1,10})?” => 'Google-Sitemaps',
„Googl(e|ebot)(-Sitemaps)” => „Google-Sitemaps”,
'Mobile.*Googlebot' => 'Google-Mobile',
'^AdsBot-Google' => 'Google-AdsBot',
'^Feedfetcher-Google' => 'Google-Feedfetcher',
'compatibil; Google Desktop' => 'Google Desktop',
'Googlebot' => 'Googlebot');
foreach( $bots ca $pattern => $bot ) {
if (preg_match( '#'.$pattern.'#i' , $UA) == 1)
{
$botname = preg_replace ( "/\\s{1,}/i" , '-' , $bot );
pauză;
}
}
if(GoogleCheker($_SERVER['REMOTE_ADDR']))
$isGoogle="Real";
elseif(GoogleChekerExtend($_SERVER['REMOTE_ADDR']))
$isGoogle="Extend";
altfel
$isGoogle="Fake";
clasa BotTracker {
track function static($s, $params){
$bot = "";
$date = matrice(
'v' => 1,
'tid' => 'UA-XXXX-1',
'cid' => self::generate_uuid(),
't' => 'eveniment',
'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' => 'EroriGoogleRender',
'el' => $params['textError']." (linia:".$params['lineError'].") - ".$params['UA']." - " .$params['botname' ]." - ".$params['isGoogle']."- ip: ".$s['REMOTE_ADDR'], //șterge după test
//'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle'] ,
'ea' => $params['RenderedURL']
);
$url = „http://www.google-analytics.com/collect”;
$conținut = http_build_query($date);
$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, $conținut);
$rezultat = curl_exec($ch);
$info= curl_getinfo($ch);
curl_close($ch);
}
funcție privată statică generate_uuid() {
returnează 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));
?>
Acum putem deja să vedem ce erori de Javascript se întâmplă atunci când Google încearcă să redea URL-urile noastre.
Trimiteți date către Google Analytics din fișierul nostru PHP
Cu această implementare, putem vedea ce erori specifice Javascript sunt generate atunci când Google încearcă să ne redeze adresele URL și în ce adrese URL specifice au loc.
Am în minte o mulțime de alte informații de urmărit cu privire la procesul de randare Google, cum ar fi verificarea dacă Googlebot încearcă anumite interacțiuni (cum ar fi derulare, un clic sau orice alt eveniment Javascript), dar voi păstra asta pentru o altă postare. Sper că v-a plăcut!