Jak wyświetlić adresy URL renderowane przez Google w Google Analytics
Opublikowany: 2021-06-11Przede wszystkim szczególne podziękowania dla Christiana za pomoc w tłumaczeniu!
Minęło kilka lat, odkąd Google zaczął wprowadzać ogromne ulepszenia w zakresie indeksowania i ładowania treści za pomocą JavaScript w taki sam sposób, w jaki zobaczyłby to prawdziwy użytkownik telefonu komórkowego.
Niemniej jednak Google nie będzie w stanie zaindeksować wszystkich znalezionych adresów URL, nawet jeśli poprawi swoją infrastrukturę, ponieważ koszt indeksowania i renderowania (proces przekształcania dokumentu HTML w strukturę wizualną) jest znacznie większy niż zwykłe indeksowanie i pobieranie kod HTML adresu URL. Samo Google to przyznało, dlatego ważne jest, aby upewnić się, że Google znajdzie, wyrenderuje i zindeksuje najważniejsze adresy URL naszej witryny, zwłaszcza w większych witrynach i/lub witrynach, które zależą od uruchamiania JS przez klienta (CSR, renderowanie po stronie klienta)
Lata temu, aby wycenić zawartość adresu URL i zdecydować, czy dodać go do indeksu, czy nie, Google wystarczyło, aby uzyskać kod HTML adresu URL (a także obrazy, które są tam połączone). Ten HTML był treścią, której Google używał do indeksowania i klasyfikowania adresu URL, bez uwzględniania tego, czy ten kod HTML został zmodyfikowany za pomocą JavaScript po renderowaniu, czy nie.
Teraz, dzięki szumowi związanemu z frameworkami JavaScript, które modyfikują stronę klienta HTML, Google musi uzyskać HTML, kod JS, style CSS i inne zasoby (jak obrazy, fronty itp.), aby renderować treść i uzyskać końcowy kod HTML, aby mógł zdecydować, czy trafi do indeksu, czy nie.
Cały ten proces nie jest wykonywany w jednej partii, jak zauważyłby zwykły użytkownik: odbywa się to w dwóch krokach. Najpierw Google indeksuje adres URL i pobiera „niewyrenderowany” kod HTML (tak jak robił to do tej pory), a chwilę później (bez ustalonej określonej ilości czasu) pobiera pozostałe zasoby, do których odwołuje się ten kod HTML, i próbuje wyrenderować stronę, aby uzyskać ostateczny, wyrenderowany kod HTML. Ten drugi krok jest określany jako „druga fala indeksowania”.
Nie musimy mieć dużej wiedzy technicznej, aby zrozumieć, że w celu przeszukania i zindeksowania wielu adresów URL koszt ich renderowania jest znacznie większy niż tylko uzyskanie niezrenderowanego kodu HTML, zarówno pod względem czasu, jak i zasobów. Tak więc, korzystając z tej samej ilości ograniczonych zasobów, Google będzie w stanie przeszukiwać i indeksować mniej adresów URL, jeśli będzie musiał je renderować. Dlatego Google musi decydować / ustalać priorytety, które adresy URL mają renderować, a które nie.
Aby zdecydować, który adres URL powinien zostać zindeksowany w następnej kolejności, Google oblicza prawdopodobieństwo zmiany tego adresu URL od czasu ostatniego indeksowania, biorąc pod uwagę inne czynniki, takie jak PageRank każdego adresu URL lub to, czy webmaster skonfigurował określone ustawienia dotyczące indeksowania częstotliwość. Ma to sens, ponieważ wydawanie ograniczonych zasobów na indeksowanie czegoś, co się nie zmieniło, jest bezużyteczne.
Chciałbym podzielić się z wami tym artykułem, ponieważ myślę, że nie jest on zbyt dobrze znany i może być bardzo odkrywczy, aby zrozumieć, w jaki sposób Google decyduje, który adres URL ma być następnie indeksowany. Został napisany przez inżynierów Google i jest matematyczną abstrakcją do rozwiązania prawdziwego problemu. Nie bój się wzorów matematycznych, jest to doskonale wyjaśnione dla osób, które nie są Data Scientistami.
Po podjęciu decyzji, który adres URL ma zaindeksować w następnej kolejności, Googlebot musi zdecydować dla każdego zindeksowanego adresu URL, czy ma go renderować, czy nie, a jeśli zdecyduje się na renderowanie adresu URL, będzie potrzebował do tego wszystkich zasobów. Aby zdecydować, czy musi zażądać każdego z potrzebnych zasobów, prawdopodobnie używa podobnego procesu matematycznego, ale z pewnymi różnicami, takimi jak czasy pamięci podręcznej, koszt uzyskania zasobu itp.
Z tego powodu bardzo ważne jest, aby wiedzieć, które adresy URL z naszej witryny są indeksowane przez Google, a także które są renderowane. Prostym sposobem na uzyskanie tych informacji, z których korzystamy w Funnel▼Punk (gdzie pracujemy z dużymi serwisami), jest analiza logów serwera (tu jest post na ten temat na moim blogu, po hiszpańsku, a drugi na blogu Oncrawla ), uzyskując pełny obraz tego, co Googlebot robi w naszej witrynie. Analiza logów może być żmudna i kosztowna dla wielu osób, dlatego chciałbym podzielić się z wami sposobem śledzenia, które adresy URL są renderowane przez Googlebota w Google Analytics.
[Studium przypadku] Zarządzanie indeksowaniem botów Google
Przeczytaj studium przypadkuLinki monitorujące renderowane przez Google
Metoda jest stosunkowo prosta, przynajmniej dla każdego zespołu programistów i dla każdego webmastera pracującego z PHP lub podobnym. Ma 3 kroki:
- Dodaj kod javascript
Kod wykryje, kiedy Googlebot wykonał JavaScript w taki sam sposób, jak zrobiłby to zwykły użytkownik, i załaduje obraz przy użyciu JavaScript (przezroczysty piksel). - Konfiguracja serwera
Skonfiguruj serwer tak, aby uruchamiał plik PHP (lub dowolny inny język programowania używany w zapleczu), gdy żądany jest adres URL przezroczystego piksela. - Wyślij dane do Google Analytics
Nasz plik PHP sprawdzi, czy Googlebot to naprawdę Googlebot, a jeśli tak, prześle dane do Google Analytics.
Dodaj kod javascript
W różnych eksperymentach, które wypróbowałem, sprawdziłem, że Googlebot wykona JavaScript tylko wtedy, gdy kod JavaScript nie wymaga interakcji użytkownika. Na przykład Googlebot wykona dowolny kod JavaScript, który zostanie wyzwolony przez zdarzenia onload lub onready. W tym przykładzie stworzymy funkcję, która zostanie wywołana zdarzeniem onLoad, czyli po załadowaniu wszystkich elementów strony.
Ta funkcja sprawdzi, czy klient użytkownika zawiera któryś ze znanych botów Googlebota, a jeśli tak, załaduje obraz (przezroczysty piksel), który nazwiemy TransparentPixelGooglebot.gif
<skrypt>
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 klient = nowy 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');
klient.wyślij(null);
}
});
</script> Za każdym razem, gdy Googlebot uzyskuje dostęp i uruchamia JavaScript, nasza funkcja zostanie uruchomiona, ładując obraz „TransparentPixelGooglebot.gif”, dodając do adresu URL obrazu pewne parametry, w których określimy konkretny adres URL, do którego uzyskano dostęp.W tej zmiennej utworzymy pełny adres URL, który zostanie poproszony o załadowanie naszego obrazu „TransparentPixelGooglebot.gif”, w którym dodamy adres URL, do którego uzyskano dostęp, a także klienta użytkownika, który o to żąda.
var trackRenderURL='https://www.mecagoenlos.com/TransparentPixelGooglebot.gif?OriginUrl='+window.location.href;
Konfiguracja serwera (.htaccess)
Następnym krokiem jest skonfigurowanie naszego serwera tak, aby za każdym razem, gdy zażądano adresu URL piksela (TransparentPixelGooglebot.gif), wykonywany był plik PHP (GooglebotRenderJS.php)
Aby to zrobić, musimy dokonać pewnych zmian w naszym pliku .htaccess (ponieważ używamy serwera Apache i PHP jako języka programowania zaplecza)
Te dwie konkretne linie to te, które sprawią, że tak się stanie:
RewriteCond %{REQUEST_URI} TransparentPixelGooglebot.gif
RewriteRule TransparentPixelGooglebot.gif(.*)$ https://www.mecagoenlos.com.com/GooglebotRenderJS.php$1Jak można się domyślić, parametry zawarte w żądaniu piksela są propagowane tak, aby plik PHP (GooglebotRenderJS.php) mógł je „odczytać”.
Dane dotyczące indeksowania³
Ucz się więcejWyślij dane do Google Analytics z pliku PHP
W naszym ostatnim kroku tworzymy plik PHP (GooglebotRenderJS.php), który będzie wykonywany za każdym razem, gdy zażądany zostanie piksel (TransparentPixelGooglebot.gif).
Ten plik:
- Sprawdź, używając odwrotnego DNS, czy żądanie zostało faktycznie wysłane przez Googlebota, czy przez fałszywego Googlebota za pomocą klienta użytkownika Googlebota
- Zidentyfikuj typ bota (Googlebot Mobile, Grafika, Reklamy itp.)
- Wyślij dane do Google Analytics (za pomocą protokołu pomiarowego Google Analytics) w ramach zdarzenia, do którego przypiszemy następujące zmienne:
- Kategoria zdarzenia: „GoogleRenderFromHtaccess”
- Akcja zdarzenia: wyrenderowany adres URL (strona odsyłająca żądania piksela)
- Etykieta zdarzenia: ciąg znaków łączący klienta użytkownika, adres IP i informację, czy bot to prawdziwy Googlebot („Real”), czy fałszywy („Fake”). Trzech z nich wysyłam do GA, aby móc sprawdzić, czy identyfikacja Googlebota działa prawidłowo.
- *Ważne: przechowywałem adres IP tylko przez kilka dni, aby sprawdzić, czy wszystko działa poprawnie, przestałem to robić później na wypadek problemów z przepisami o ochronie danych
<?php
header("Dyrektywa pragma: brak pamięci podręcznej");
header("Dyrektywa pamięci podręcznej: brak pamięci podręcznej");
header("Kontrola pamięci podręcznej: brak pamięci podręcznej");
header("Pragma: brak pamięci podręcznej");
header("Wygasa: 0");
if ($_GET["OriginUrl"])
$src=$_GET["UrlPochodzenia"];
w przeciwnym razie
$src = $_SERVER['HTTP_REFERER'];
$UA=$_SERVER["HTTP_USER_AGENT"];
$RenderParameters=$_GET["RenderParameters"];
funkcja GoogleCheker($IP){
# aby uniknąć niepotrzebnego wyszukiwania, sprawdź tylko, czy UA pasuje do jednego z
# boty, które lubimy
$nazwa hosta=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/googlebot/i",$nazwa hosta))
if ($ip_by_hostname == $Ip)
zwróć prawdę;
w przeciwnym razie
zwróć fałsz;
w przeciwnym razie
zwróć fałsz;
}
funkcja GoogleChekerExtend($Ip){
# aby uniknąć niepotrzebnego wyszukiwania, sprawdź tylko, czy UA pasuje do jednego z
# boty, które lubimy
$nazwa hosta=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/\.google\.com[\.]?$/i",$nazwa hosta))
if ($ip_by_hostname == $Ip)
zwróć prawdę;
w przeciwnym razie
zwróć fałsz;
w przeciwnym razie
zwróć fałsz;
}
$botname="Rozpocznij";
$bots = array('Mediapartners-Google[ /]([0-9.]{1,10})' => 'Google Mediapartners',
'Mediapartners-Google' => 'Google Mediapartners',
'Googl(e|ebot)(-Obraz)/([0-9.]{1,10})' => 'Obraz Google',
'Googl(e|ebot)(-Image)/' => 'Grafika Google',
'^gsa-crawler' => 'Google',
'Googl(e|ebot)(-Mapy witryn)/([0-9.]{1,10})?' => 'Mapy witryn Google',
'GsiteCrawler[ /v]*([0-9.az]{1,10})?' => 'Mapy witryn Google',
'Googl(e|ebot)(-Mapy witryn)' => 'Mapy witryn Google',
'Mobile.*Googlebot' => 'Google-Mobile',
'^AdsBot-Google' => 'Google-AdsBot',
'^Feedfetcher-Google' => 'Google-Feedfetcher',
'zgodny; Google Desktop' => 'Google Desktop',
„Googlebot” => „Googlebot”);
foreach( $boty jako $pattern => $bot ) {
if ( preg_match( '#'.$pattern.'#i' , $UA) == 1 )
{
$nazwa_bota = preg_replace ( "/\\s{1,}/i" , '-' , $bot );
złamać;
}
}
if(GoogleCheker($_SERVER['REMOTE_ADDR']))
$isGoogle="Prawdziwy";
elseif(GoogleChekerExtend($_SERVER['REMOTE_ADDR']))
$isGoogle="Rozszerz";
w przeciwnym razie
$isGoogle="Fałszywe";
klasa BotTracker {
ścieżka funkcji statycznej($s, $params){
$bot = "";
$dane = tablica(
'v' => 1,
'tid' => 'UA-XXXXXXX-1',
'cid' => self::generate_uuid(),
't' => 'zdarzenie',
'dh' => $s['HTTP_HOST'],
'dl' => $s['REQUEST_URI'],
'dr' => $s['HTTP_REFERER'],
'dp' => $s['REQUEST_URI'],
'dt' => $params['tytuł_strony'],
'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'], //usuń po teście
//'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle'] ,
'ea' => $params['RenderedURL']
);
$url = 'http://www.google-analytics.com/collect';
$treść = http_build_query($dane);
$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('Typ treści: aplikacja/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, $zawartość);
$wynik = curl_exec($ch);
$info= curl_getinfo($ch);
curl_close($ch);
}
statyczna funkcja prywatna 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));
?>
Sprawdź, czy nasza konfiguracja działa w Google Analytics
Wszystko gotowe! Teraz możemy sprawdzić, czy wszystko działa zgodnie z oczekiwaniami. W tym celu możemy skorzystać z raportu Czas rzeczywisty z Google Analytics i wybrać raport „Zdarzenia”. Na innej karcie otwieramy Search Console, przechodzimy do właściwości naszej witryny i używamy Inspektora adresów URL, aby zmusić Google do indeksowania i renderowania dowolnego z naszych adresów URL. Jeśli wszystko działa, zobaczysz nowe zdarzenia w raporcie zdarzeń w czasie rzeczywistym Google Analytics.
Jak zobaczysz, te zdarzenia nie będą liczone jako aktywni użytkownicy w naszej witrynie, ponieważ zdarzenie jest skonfigurowane z parametrem „nonInteraction”.
Jeśli klikniemy kategorię zdarzenia „GoogleRenderFromHtaccess”, będziemy mogli zobaczyć agenta użytkownika, adres IP i czy bot został zidentyfikowany jako prawdziwy lub fałszywy.
Błędy śledzenia generowane przez Google podczas próby renderowania adresu URL
Widzieliśmy już, jak możemy śledzić i sprawdzać, które adresy URL są renderowane przez Google. Możemy jednak pójść dalej i śledzić, które błędy Javascript są generowane, gdy Google próbuje renderować adresy URL naszej witryny.
Podczas renderowania JavaScript mogą być generowane błędy, które są widoczne tylko w przeglądarce użytkownika (a nie na naszym serwerze), więc śledzenie tych błędów nie jest łatwym zadaniem.
Obecnie, jeśli chcemy sprawdzić, jakie błędy Javascript są generowane, gdy Googlebot renderuje nasze adresy URL, możemy to zrobić tylko za pomocą Inspektora adresów URL w Search Console
- Sprawdź adres URL:
- Kliknij „Testuj adres URL na żywo”:
- Sprawdź, czy są jakieś błędy:
Wykonanie tego ręcznie w przypadku wielu adresów URL to dużo pracy, ale możemy użyć kodu, który właśnie pokazałem, aby śledzić, czy występują błędy JavaScript, gdy Googlebot próbuje renderować nasze adresy URL.
Przykład błędu wygenerowanego celowo w celu sprawdzenia, czy kod działa:
Dodaj kod JavaScript
W ten sam sposób, w jaki zrobiliśmy to w poprzednim przykładzie, przechwycimy każdy błąd JavaScript za pomocą tego wiersza kodu: "window.addEventListener('error', function(e)" .
Za każdym razem, gdy wystąpi błąd, zostanie uruchomiona funkcja, która pozwoli nam te błędy zapisać i przesłać do Google Analytics. Będzie to bardzo podobne do tego, co zrobiliśmy w poprzednim przykładzie, z zastrzeżeniem, że ta funkcja zostanie wykonana tylko wtedy, gdy wystąpi błąd JavaScript.
window.addEventListener('błąd', 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 klient = nowy XMLHttpRequest();
var ErrorsURLPixel='https://www.mecagoenlos.com/TransparentPixelGooglebotError.gif?OriginUrl='+window.location.href+'&textError='+unescape(encodeURIComponent(e.message))+'&LineError='+unescape(encodeURICom) (e.lineno.toString()))+'&UA='+unescape(encodeURIComponent(userAgent));
client.open('POBIERZ',BłędyURLPixel);
client.setRequestHeader('Content-Type', 'text/plain;charset=UTF-8');
klient.wysłać(e);
}
});
Ten kod wykona funkcję, która załaduje kolejny przezroczysty piksel (TransparentPixelGooglebotError.gif), dodając jako parametry renderowany adres URL, błąd i agenta użytkownika, generując żądanie do adresu URL w następujący sposób:
var ErrorsURLPixel='https://www.mecagoenlos.com/TransparentPixelGooglebotError.gif?OriginUrl='+window.location.href+'&textError='+unescape(encodeURIComponent(e.message))+'&LineError='+unescape(encodeURICom) (e.lineno.toString()))+'&UA='+unescape(encodeURIComponent(userAgent));
Konfiguracja serwera (.htaccess)
W ten sam sposób, jak w poprzednim przykładzie, dodamy kilka reguł w .htaccess, aby wykryć, kiedy piksel jest załadowany i wykonać plik PHP:
RewriteCond %{REQUEST_URI} TransparentPixelGooglebotError.gif
RewriteRule TransparentPixelGooglebotError.gif(.*)$ https://modelode.com/GooglebotErrorRenderJS.php$1 W ten sposób za każdym razem, gdy zostanie wyświetlony monit „https://www.mecagoenlos.com/TransparentPixelGooglebotError.gif”, zostanie wykonany plik PHP „GooglebotErrorRenderJS.php”.
Plik PHP
Ten plik PHP sprawdzi, czy Googlebot jest prawdziwy i wyśle dane do Google Analytics za pomocą zdarzenia z kategorią „BłędyGoogleRender”, używając wyrenderowanego adresu URL jako akcji zdarzenia i samego błędu jako etykiety zdarzenia.
<?php
header("Dyrektywa pragma: brak pamięci podręcznej");
header("Dyrektywa pamięci podręcznej: brak pamięci podręcznej");
header("Kontrola pamięci podręcznej: brak pamięci podręcznej");
header("Pragma: brak pamięci podręcznej");
header("Wygasa: 0");
if ($_GET["OriginUrl"])
$src=$_GET["UrlPochodzenia"];
w przeciwnym razie
$src = $_SERVER['HTTP_REFERER'];
$UA=$_SERVER["HTTP_USER_AGENT"];
$RenderParameters=$_GET["RenderParameters"];
$textError=$_GET["textError"];
$lineError=$_GET["LineError"];
funkcja GoogleCheker($IP){
# aby uniknąć niepotrzebnego wyszukiwania, sprawdź tylko, czy UA pasuje do jednego z
# boty, które lubimy
$nazwa hosta=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/googlebot/i",$nazwa hosta))
if ($ip_by_hostname == $Ip)
zwróć prawdę;
w przeciwnym razie
zwróć fałsz;
w przeciwnym razie
zwróć fałsz;
}
funkcja GoogleChekerExtend($Ip){
# aby uniknąć niepotrzebnego wyszukiwania, sprawdź tylko, czy UA pasuje do jednego z
# boty, które lubimy
$nazwa hosta=gethostbyaddr($Ip);
$ip_by_hostname=gethostbyname($hostname);
if(preg_match("/\.google\.com[\.]?$/i",$nazwa hosta))
if ($ip_by_hostname == $Ip)
zwróć prawdę;
w przeciwnym razie
zwróć fałsz;
w przeciwnym razie
zwróć fałsz;
}
$botname="Rozpocznij";
$bots = array('Mediapartners-Google[ /]([0-9.]{1,10})' => 'Google Mediapartners',
'Mediapartners-Google' => 'Google Mediapartners',
'Googl(e|ebot)(-Obraz)/([0-9.]{1,10})' => 'Obraz Google',
'Googl(e|ebot)(-Image)/' => 'Grafika Google',
'^gsa-crawler' => 'Google',
'Googl(e|ebot)(-Mapy witryn)/([0-9.]{1,10})?' => 'Mapy witryn Google',
'GsiteCrawler[ /v]*([0-9.az]{1,10})?' => 'Mapy witryn Google',
'Googl(e|ebot)(-Mapy witryn)' => 'Mapy witryn Google',
'Mobile.*Googlebot' => 'Google-Mobile',
'^AdsBot-Google' => 'Google-AdsBot',
'^Feedfetcher-Google' => 'Google-Feedfetcher',
'zgodny; Google Desktop' => 'Google Desktop',
„Googlebot” => „Googlebot”);
foreach( $boty jako $pattern => $bot ) {
if ( preg_match( '#'.$pattern.'#i' , $UA) == 1 )
{
$nazwa_bota = preg_replace ( "/\\s{1,}/i" , '-' , $bot );
złamać;
}
}
if(GoogleCheker($_SERVER['REMOTE_ADDR']))
$isGoogle="Prawdziwy";
elseif(GoogleChekerExtend($_SERVER['REMOTE_ADDR']))
$isGoogle="Rozszerz";
w przeciwnym razie
$isGoogle="Fałszywe";
klasa BotTracker {
ścieżka funkcji statycznej($s, $params){
$bot = "";
$dane = tablica(
'v' => 1,
'tid' => 'UA-XXXX-1',
'cid' => self::generate_uuid(),
't' => 'zdarzenie',
'dh' => $s['HTTP_HOST'],
'dl' => $s['REQUEST_URI'],
'dr' => $s['HTTP_REFERER'],
'dp' => $s['REQUEST_URI'],
'dt' => $params['tytuł_strony'],
'ck' => $s['HTTP_USER_AGENT'],
'uip' => $s['REMOTE_ADDR'],
'ni' => 1,
'ec' => 'Błędy GoogleRender',
'el' => $params['textError']." (line:".$params['lineError'].") - ".$params['UA']." - " .$params['nazwa_bota' ]." - ".$params['isGoogle']."- ip: ".$s['REMOTE_ADDR'], //usuń po teście
//'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle'] ,
'ea' => $params['RenderedURL']
);
$url = 'http://www.google-analytics.com/collect';
$treść = http_build_query($dane);
$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('Typ treści: aplikacja/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, $zawartość);
$wynik = curl_exec($ch);
$info= curl_getinfo($ch);
curl_close($ch);
}
statyczna funkcja prywatna 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));
?>
Teraz możemy już zobaczyć, które błędy JavaScript występują, gdy Google próbuje renderować nasze adresy URL.
Wysyłaj dane do Google Analytics z naszego pliku PHP
Dzięki tej implementacji możemy zobaczyć, które konkretne błędy Javascript są generowane, gdy Google próbuje renderować nasze adresy URL i w których konkretnych adresach URL występują.
Mam na myśli wiele innych informacji dotyczących procesu renderowania Google, takich jak sprawdzanie, czy Googlebot próbuje jakichś interakcji (takich jak przewijanie, kliknięcie lub jakiekolwiek inne zdarzenie JavaScript), ale zachowam to w innym poście. Mam nadzieje ze ci się podobało!