So zeigen Sie von Google gerenderte URLs in Google Analytics an
Veröffentlicht: 2021-06-11Zunächst einmal ein besonderer Dank an Christian, der mir bei der Übersetzung geholfen hat!
Es ist mehrere Jahre her, seit Google damit begonnen hat, seine Kapazität zum Crawlen und Laden von Inhalten mit Javascript so zu verbessern, wie es ein echter Benutzer mit einem Mobiltelefon sehen würde.
Trotzdem wird Google nicht alle gefundenen URLs crawlen können, selbst wenn es seine Infrastruktur verbessert, da die Kosten für das Crawlen und Rendern (der Prozess der Umwandlung eines HTML-Dokuments in eine visuelle Struktur) enorm höher sind als das einfache Crawlen und Abrufen den HTML-Code einer URL. Google selbst hat dies anerkannt, daher ist es wichtig sicherzustellen, dass Google die wichtigsten URLs unserer Website findet, rendert und indexiert, insbesondere bei größeren Websites und/oder Websites, die davon abhängen, dass JS vom Client ausgeführt wird (CSR, Client Side Rendering).
Um den Inhalt einer URL zu bewerten und zu entscheiden, ob sie in den Index aufgenommen wird oder nicht, hatte Google vor Jahren genug davon, den HTML-Code der URL (sowie die dort verlinkten Bilder) zu erhalten. Dieser HTML-Code war der Inhalt, den Google verwendet hat, um die URL zu indizieren und einzustufen, ohne zu berücksichtigen, ob dieser HTML-Code nach dem Rendern mithilfe von Javascript geändert wurde oder nicht.
Jetzt, mit dem Hype um Javascript-Frameworks, die das HTML clientseitig modifizieren, muss Google den HTML-Code, den JS-Code, die CSS-Stile und andere Ressourcen (wie Bilder, Fronten usw.) erhalten, um den Inhalt zu rendern und zu erhalten das endgültige HTML, damit es entscheiden kann, ob es in den Index geht oder nicht.
Dieser gesamte Prozess wird nicht in einem Stapel ausgeführt, wie es ein normaler Benutzer sehen würde: Er wird in zwei Schritten ausgeführt. Zuerst crawlt Google die URL und ruft den „nicht gerenderten“ HTML-Code ab (wie bisher), und eine Weile später (ohne festgelegte Zeitspanne) ruft es den Rest der Ressourcen ab, auf die in diesem HTML verwiesen wird, und versucht es zum Rendern der Seite, um den endgültigen, gerenderten HTML-Code zu erhalten. Dieser zweite Schritt wird als „zweite Indizierungswelle“ bezeichnet.
Wir brauchen nicht viel technisches Wissen, um zu verstehen, dass die Kosten für das Crawlen und Indizieren einer Reihe von URLs viel größer sind als nur das Erhalten des nicht gerenderten HTML, sowohl in Bezug auf Zeit als auch auf Ressourcen. Mit der gleichen Menge endlicher Ressourcen kann Google also weniger URLs crawlen und indizieren, wenn es sie rendern muss. Aus diesem Grund muss Google entscheiden/priorisieren, welche URLs gerendert werden und welche nicht.
Um zu entscheiden, welche URL als nächstes gecrawlt werden soll, berechnet Google die Wahrscheinlichkeit, dass sich diese URL seit dem letzten Crawlen geändert hat, wobei andere Faktoren wie der PageRank jeder URL oder ob der Webmaster eine bestimmte Einstellung zum Crawlen konfiguriert hat, berücksichtigt werden Frequenz. Dies ist sinnvoll, da es sinnlos ist, begrenzte Ressourcen für das Crawlen von etwas zu verwenden, das sich nicht geändert hat.
Ich möchte diesen Artikel mit Ihnen teilen, da ich denke, dass er nicht wirklich bekannt ist und sehr aufschlussreich sein kann, um zu verstehen, wie Google entscheidet, welche URL als nächstes gecrawlt wird. Es wurde von den Google-Ingenieuren geschrieben und ist eine mathematische Abstraktion zur Lösung eines echten Problems. Erschrecken Sie nicht vor den mathematischen Formeln, es ist perfekt erklärt für Leute, die keine Data Scientists sind.
Nach der Entscheidung, welche URL als nächstes gecrawlt werden soll, muss der Googlebot für jede gecrawlte URL entscheiden, ob er diese URL rendern soll oder nicht, und wenn er sich entscheidet, eine URL zu rendern, benötigt er alle Ressourcen, um dies zu erreichen. Um zu entscheiden, ob jede der benötigten Ressourcen angefordert werden muss, verwendet es wahrscheinlich einen ähnlichen mathematischen Prozess, jedoch mit einigen Unterschieden wie Cache-Zeiten, Kosten für den Erhalt der Ressource usw.
Aus diesem Grund ist es sehr wichtig zu wissen, welche URLs unserer Website von Google gecrawlt und welche gerendert werden. Eine einfache Möglichkeit, diese Informationen zu erhalten, die wir bei Funnel▼Punk verwenden (wo wir mit großen Websites arbeiten), besteht darin, die Serverprotokolle zu analysieren (hier ist ein Beitrag dazu in meinem Blog auf Spanisch und ein weiterer im Blog von Oncrawl). ), um ein vollständiges Bild davon zu erhalten, was der Googlebot auf unserer Website macht. Die Protokollanalyse kann für viele Menschen mühsam und teuer sein, deshalb möchte ich mit Ihnen eine Möglichkeit teilen, zu verfolgen, welche URLs vom Googlebot in Google Analytics gerendert werden.
[Fallstudie] Verwaltung des Bot-Crawlings von Google
Lesen Sie die FallstudieVon Google gerenderte Tracking-URLs
Die Methode ist relativ einfach, zumindest für jedes Entwicklerteam und für jeden Webmaster, der es gewohnt ist, mit PHP oder ähnlichem zu arbeiten. Es hat 3 Schritte:
- Javascript-Code hinzufügen
Der Code erkennt, wenn der Googlebot Javascript genauso ausgeführt hat wie ein normaler Benutzer, und lädt ein Bild mit Javascript (ein transparentes Pixel). - Serverkonfig
Konfigurieren Sie den Server so, dass er eine PHP-Datei (oder eine andere im Backend verwendete Programmiersprache) ausführt, wenn die URL des transparenten Pixels angefordert wird. - Senden Sie die Daten an Google Analytics
Unsere PHP-Datei prüft, ob der Googlebot wirklich ein Googlebot ist und sendet die Daten in diesem Fall an Google Analytics.
Javascript-Code hinzufügen
In verschiedenen Experimenten, die ich ausprobiert habe, habe ich überprüft, dass der Googlebot Javascript nur dann ausführt, wenn der Javascript-Code keine Benutzerinteraktion erfordert. Der Googlebot führt beispielsweise jeden Javascript-Code aus, der mit den onload- oder onready-Ereignissen ausgelöst wird. In diesem Beispiel erstellen wir eine Funktion, die mit dem onLoad-Ereignis ausgelöst wird, d. h. wenn alle Elemente der Seite geladen sind.
Diese Funktion prüft, ob der User Agent einen der bekannten Bots des Googlebots enthält, und lädt in diesem Fall ein Bild (ein transparentes Pixel), das wir als TransparentPixelGooglebot.gif bezeichnen
<Skript>
window.addEventListener("load", function(){
var botPattern = "googlebot|Googlebot-Mobile|Googlebot-Bild|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> Jedes Mal, wenn der Googlebot auf Javascript zugreift und es ausführt, wird unsere Funktion ausgelöst, lädt das Bild „TransparentPixelGooglebot.gif“ und fügt der URL des Bildes einige Parameter hinzu, in denen wir die spezifische URL angeben, auf die zugegriffen wurde.In dieser Variable setzen wir die vollständige URL zusammen, die zum Laden unseres Bildes „TransparentPixelGooglebot.gif“ angefordert wird, wobei wir die URL, auf die zugegriffen wird, sowie den Benutzeragenten hinzufügen, der sie anfordert.
var trackRenderURL='https://www.mecagoenlos.com/TransparentPixelGooglebot.gif?OriginUrl='+window.location.href;
Serverkonfiguration (.htaccess)
Als Nächstes konfigurieren wir unseren Server so, dass immer dann, wenn die URL des Pixels (TransparentPixelGooglebot.gif) angefordert wird, eine PHP-Datei ausgeführt wird (GooglebotRenderJS.php).
Dazu müssen wir einige Änderungen in unserer .htaccess-Datei vornehmen (da wir einen Apache-Server und PHP als Backend-Programmiersprache verwenden)
Diese beiden spezifischen Zeilen sind diejenigen, die das bewirken werden:
RewriteCond %{REQUEST_URI} TransparentPixelGooglebot.gif
RewriteRule TransparentPixelGooglebot.gif(.*)$ https://www.mecagoenlos.com.com/GooglebotRenderJS.php$1Wie Sie sich vorstellen können, werden die in der Pixelanfrage enthaltenen Parameter weitergegeben, damit die PHP-Datei (GooglebotRenderJS.php) sie „lesen“ kann.
Oncrawl-Daten³
Mehr erfahrenSenden Sie die Daten aus der PHP-Datei an Google Analytics
In unserem letzten Schritt erstellen wir die PHP-Datei (GooglebotRenderJS.php), die immer dann ausgeführt wird, wenn das Pixel (TransparentPixelGooglebot.gif) angefordert wird.
Diese Datei wird:
- Überprüfen Sie mithilfe von Reverse-DNS, ob die Anfrage tatsächlich von Googlebot oder einem gefälschten Googlebot mit dem User Agent von Googlebot stammt
- Identifizieren Sie, um welche Art von Bot es sich handelt (Googlebot Mobile, Bilder, Anzeigen usw.)
- Senden Sie die Daten an Google Analytics (unter Verwendung des Messprotokolls von Google Analytics) innerhalb eines Ereignisses, in dem wir die folgenden Variablen zuweisen:
- Ereigniskategorie: „GoogleRenderFromHtaccess“
- Ereignisaktion: Gerenderte URL (der Referrer der Pixelanforderung)
- Event Label: Eine Zeichenfolge, die den Benutzeragenten, die IP und ob der Bot ein echter Googlebot („Real“) oder ein gefälschter („Fake“) ist, verkettet. Ich schicke die drei zu GA, um zu sehen, ob die Identifizierung des Googlebots korrekt funktioniert.
- *Wichtig: Ich habe die IP nur für ein paar Tage gespeichert, um zu testen, ob alles richtig funktioniert, danach habe ich damit aufgehört, falls es irgendwelche Probleme mit Datenschutzgesetzen gibt
<?php
header("Pragma-Direktive: no-cache");
header("Cache-Direktive: no-cache");
header("Cache-Steuerung: kein Cache");
header("Pragma: no-cache");
header("Läuft ab: 0");
if ($_GET["OriginUrl"])
$src=$_GET["OriginUrl"];
anders
$src = $_SERVER['HTTP_REFERER'];
$UA=$_SERVER["HTTP_USER_AGENT"];
$RenderParameters=$_GET["RenderParameter"];
Funktion GoogleCheker($Ip){
# Um unnötiges Nachschlagen zu vermeiden, prüfen Sie nur, ob der UA mit einem von übereinstimmt
# die Bots, die wir mögen
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/googlebot/i",$hostname))
if ($ip_by_hostname == $Ip)
gib true zurück;
anders
falsch zurückgeben;
anders
falsch zurückgeben;
}
Funktion GoogleChekerExtend($Ip){
# Um unnötiges Nachschlagen zu vermeiden, prüfen Sie nur, ob der UA mit einem von übereinstimmt
# die Bots, die wir mögen
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/\.google\.com[\.]?$/i",$hostname))
if ($ip_by_hostname == $Ip)
gib true zurück;
anders
falsch zurückgeben;
anders
falsch zurückgeben;
}
$botname="Init";
$bots = array('Mediapartners-Google[ /]([0-9.]{1,10})' => 'Google Mediapartners',
'Mediapartners-Google' => 'Google Mediapartners',
'Google(e|ebot)(-Bild)/([0-9.]{1,10})' => 'Google-Bild',
'Google(e|ebot)(-Bild)/' => 'Google-Bild',
'^gsa-crawler' => 'Google',
'Google(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',
'kompatibel; 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 );
brechen;
}
}
if(GoogleCheker($_SERVER['REMOTE_ADDR']))
$isGoogle="Real";
elseif(GoogleChekerExtend($_SERVER['REMOTE_ADDR']))
$isGoogle="Erweitern";
anders
$isGoogle="Fake";
Klasse BotTracker {
Statische Funktionsspur($s, $params){
$bot = "";
$daten = array(
'v' => 1,
'tid' => 'UA-XXXXXXX-1',
'cid' => self::generate_uuid(),
't' => 'Ereignis',
'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'], // nach Test löschen
//'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle'] ,
'ea' => $params['RenderedURL']
);
$url = 'http://www.google-analytics.com/collect';
$content = http_build_query($daten);
$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);
}
statische private Funktion 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));
?>
Überprüfen Sie, ob unser Setup in Google Analytics funktioniert
Alles ist eingerichtet! Jetzt können wir überprüfen, ob alles wie erwartet funktioniert. Dazu können wir den Echtzeitbericht von Google Analytics verwenden und den Bericht „Ereignisse“ auswählen. Auf einer anderen Registerkarte öffnen wir die Search Console, gehen zum Eigentum unserer Website und verwenden den URL-Inspektor, um Google zu zwingen, eine unserer URLs zu crawlen und zu rendern. Wenn alles funktioniert, sehen Sie neue Ereignisse im Echtzeit-Ereignisbericht von Google Analytics.
Wie Sie sehen werden, werden diese Ereignisse nicht als aktive Benutzer auf unserer Website gezählt, da das Ereignis mit dem Parameter „nonInteraction“ konfiguriert ist.
Wenn wir auf die Event-Kategorie „GoogleRenderFromHtaccess“ klicken, sehen wir den User Agent, die IP und ob der Bot als echt oder gefälscht identifiziert wurde.
Tracking-Fehler, die von Google generiert werden, wenn versucht wird, eine URL zu rendern
Wir haben bereits gesehen, wie wir nachverfolgen und prüfen können, welche URLs von Google gerendert werden. Aber wir können noch weiter gehen und nachverfolgen, welche Javascript-Fehler generiert werden, wenn Google versucht, URLs unserer Website zu rendern.
Wenn Javascript gerendert wird, können Fehler generiert werden, die nur im Browser des Benutzers (und nicht auf unserem Server) sichtbar sind, daher ist es keine leichte Aufgabe, diese Fehler zu verfolgen.
Wenn wir heutzutage überprüfen möchten, welche Javascript-Fehler generiert werden, wenn der Googlebot unsere URLs rendert, können wir dies nur mit dem URL-Inspektor in der Search Console tun
- Überprüfen Sie eine URL:
- Klicken Sie auf „Live-URL testen“:
- Überprüfen Sie, ob es Fehler gibt:
Dies manuell für viele URLs zu tun, ist eine Menge Arbeit, aber wir können den Code, den ich Ihnen gerade gezeigt habe, verwenden, um nachzuverfolgen, ob JavaScript-Fehler auftreten, wenn der Googlebot versucht, unsere URLs zu rendern.
Beispiel für einen absichtlich generierten Fehler, um zu überprüfen, ob der Code funktioniert:
Javascript-Code hinzufügen
Genauso wie im vorherigen Beispiel erfassen wir alle Javascript-Fehler mit dieser Codezeile: "window.addEventListener('error', function(e)" .
Jedes Mal, wenn ein Fehler generiert wird, wird eine Funktion ausgeführt, die es uns ermöglicht, diese Fehler zu speichern und an Google Analytics zu senden. Dies wird dem, was wir im vorherigen Beispiel getan haben, sehr ähnlich sein, mit der Einschränkung, dass diese Funktion nur ausgeführt wird, wenn ein Javascript-Fehler auftritt.
window.addEventListener('error', function(e) {
var botPattern = "googlebot|Googlebot-Mobile|Googlebot-Bild|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);
}
});
Dieser Code führt die Funktion aus, die ein weiteres transparentes Pixel lädt (TransparentPixelGooglebotError.gif), fügt als Parameter die gerenderte URL, den Fehler und den Benutzeragenten hinzu und generiert eine Anfrage an eine URL wie diese:
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));
Serverkonfiguration (.htaccess)
Genauso wie im vorherigen Beispiel fügen wir einige Regeln in die .htaccess-Datei ein, um zu erkennen, wann das Pixel geladen wird, und führen eine PHP-Datei aus:
RewriteCond %{REQUEST_URI} TransparentPixelGooglebotError.gif
RewriteRule TransparentPixelGooglebotError.gif(.*)$ https://modelode.com/GooglebotErrorRenderJS.php$1 Auf diese Weise wird immer dann, wenn „https://www.mecagoenlos.com/TransparentPixelGooglebotError.gif“ angefordert wird, die PHP-Datei „GooglebotErrorRenderJS.php“ ausgeführt.
PHP-Datei
Diese PHP-Datei prüft, ob der Googlebot echt ist, und sendet die Daten mithilfe eines Ereignisses mit der Kategorie „ErrorsGoogleRender“ an Google Analytics, wobei die gerenderte URL als Ereignisaktion und der Fehler selbst als Ereignisbezeichnung verwendet werden.
<?php
header("Pragma-Direktive: no-cache");
header("Cache-Direktive: no-cache");
header("Cache-Steuerung: kein Cache");
header("Pragma: no-cache");
header("Läuft ab: 0");
if ($_GET["OriginUrl"])
$src=$_GET["OriginUrl"];
anders
$src = $_SERVER['HTTP_REFERER'];
$UA=$_SERVER["HTTP_USER_AGENT"];
$RenderParameters=$_GET["RenderParameter"];
$textError=$_GET["textError"];
$lineError=$_GET["LineError"];
Funktion GoogleCheker($Ip){
# Um unnötiges Nachschlagen zu vermeiden, prüfen Sie nur, ob der UA mit einem von übereinstimmt
# die Bots, die wir mögen
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/googlebot/i",$hostname))
if ($ip_by_hostname == $Ip)
gib true zurück;
anders
falsch zurückgeben;
anders
falsch zurückgeben;
}
Funktion GoogleChekerExtend($Ip){
# Um unnötiges Nachschlagen zu vermeiden, prüfen Sie nur, ob der UA mit einem von übereinstimmt
# die Bots, die wir mögen
$hostname=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/\.google\.com[\.]?$/i",$hostname))
if ($ip_by_hostname == $Ip)
gib true zurück;
anders
falsch zurückgeben;
anders
falsch zurückgeben;
}
$botname="Init";
$bots = array('Mediapartners-Google[ /]([0-9.]{1,10})' => 'Google Mediapartners',
'Mediapartners-Google' => 'Google Mediapartners',
'Google(e|ebot)(-Bild)/([0-9.]{1,10})' => 'Google-Bild',
'Google(e|ebot)(-Bild)/' => 'Google-Bild',
'^gsa-crawler' => 'Google',
'Google(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',
'kompatibel; 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 );
brechen;
}
}
if(GoogleCheker($_SERVER['REMOTE_ADDR']))
$isGoogle="Real";
elseif(GoogleChekerExtend($_SERVER['REMOTE_ADDR']))
$isGoogle="Erweitern";
anders
$isGoogle="Fake";
Klasse BotTracker {
Statische Funktionsspur($s, $params){
$bot = "";
$daten = array(
'v' => 1,
'tid' => 'UA-XXXX-1',
'cid' => self::generate_uuid(),
't' => 'Ereignis',
'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'], //Nach Test löschen
//'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle'] ,
'ea' => $params['RenderedURL']
);
$url = 'http://www.google-analytics.com/collect';
$content = http_build_query($daten);
$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);
}
statische private Funktion 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));
?>
Jetzt können wir bereits sehen, welche Javascript-Fehler auftreten, wenn Google versucht, unsere URLs zu rendern.
Senden Sie Daten aus unserer PHP-Datei an Google Analytics
Mit dieser Implementierung können wir sehen, welche spezifischen Javascript-Fehler generiert werden, wenn Google versucht, unsere URLs zu rendern, und in welchen spezifischen URLs sie auftreten.
Ich habe viele andere Informationen im Sinn, die ich bezüglich des Rendering-Prozesses von Google nachverfolgen möchte, wie zum Beispiel zu überprüfen, ob der Googlebot einige Interaktionen versucht (wie Scrollen, ein Klick oder ein anderes Javascript-Ereignis), aber ich behalte das für einen anderen Beitrag. Hoffe es hat euch gefallen!