Cómo ver las URL renderizadas por Google en Google Analytics
Publicado: 2021-06-11En primer lugar, ¡gracias especiales a Christian por ayudarme con la traducción!
Han pasado varios años desde que Google comenzó a hacer grandes mejoras en su capacidad para rastrear y cargar el contenido con Javascript de la misma manera que lo vería un usuario real con un teléfono móvil.
Sin embargo, Google no podrá rastrear todas las URL que encuentre, incluso si mejora su infraestructura, ya que el costo de rastrear y renderizar (el proceso de transformar un documento HTML en una estructura visual) es mucho mayor que simplemente rastrear y obtener el HTML de una URL. Google mismo reconoció esto, por lo que es importante asegurarse de que Google encontrará, renderizará e indexará las URL más importantes de nuestro sitio, especialmente en sitios más grandes y/o sitios que dependen de que el cliente ejecute JS (CSR, Client Side Rendering)
Hace años, para valorar el contenido de una URL y decidir si añadirla o no al índice, Google se hartaba de conseguir el HTML de la URL (así como las imágenes allí enlazadas). Ese HTML fue el contenido que usó Google para indexar y clasificar la URL, sin tener en cuenta si ese HTML se modificó usando Javascript después de renderizar o no.
Ahora, con la exageración de los marcos de Javascript que modifican el lado del cliente HTML, Google necesita obtener el HTML, el código JS, los estilos CSS y otros recursos (como imágenes, frentes, etc.) para representar el contenido y obtener el HTML final, para que pueda decidir si va al índice o no.
Todo este proceso no se realiza en un lote como vería un usuario normal: se realiza en dos pasos. Primero, Google rastrea la URL y obtiene el HTML "no renderizado" (como lo ha estado haciendo hasta ahora), y un tiempo después (sin una cantidad de tiempo fija especificada), obtiene el resto de los recursos a los que se hace referencia en ese HTML e intenta para renderizar la página para obtener el HTML renderizado final. Este segundo paso se conoce como "segunda ola de indexación".
No necesitamos tener muchos conocimientos técnicos para comprender que, para rastrear e indexar una cantidad de URL, el costo de renderizarlas es mucho mayor que simplemente obtener el HTML sin renderizar, tanto en tiempo como en recursos. Por lo tanto, con la misma cantidad de recursos finitos, Google podrá rastrear e indexar menos URL si necesita procesarlas. Es por eso que Google necesita decidir/priorizar qué URL mostrar y cuáles no.
Para decidir qué URL se debe rastrear a continuación, Google calcula la probabilidad de que esa URL haya cambiado desde la última vez que se rastreó, teniendo en cuenta otros factores como el PageRank de cada URL o si el webmaster ha configurado alguna configuración específica con respecto al rastreo. frecuencia. Esto tiene sentido ya que es inútil gastar recursos limitados en rastrear algo que no ha cambiado.
Me gustaría compartir este artículo contigo porque creo que no es muy conocido y puede ser muy revelador para entender cómo Google decide qué URL rastrear a continuación. Está escrito por los ingenieros de Google y es una abstracción matemática para resolver un problema real. No te asustes con las fórmulas matemáticas, está perfectamente explicado para personas que no son Data Scientists.
Después de decidir qué URL rastrear a continuación, Googlebot debe decidir, para cada URL rastreada, si debe mostrar esa URL o no, y si decide mostrar una URL, necesitará todos los recursos para lograrlo. Para decidir si necesita solicitar cada uno de los recursos necesarios, probablemente utilice un proceso matemático similar pero con algunas diferencias como tiempos de caché, costo de obtención del recurso, etc.
Por todo esto, es muy importante saber qué URL de nuestro sitio están siendo rastreadas por Google, y también cuáles están siendo procesadas. Una forma fácil de obtener esa información, que usamos en Funnel▼Punk (donde trabajamos con grandes sitios web), es analizando los registros del servidor (aquí hay una publicación sobre eso en mi blog, en español, y otra en el blog de Oncrawl). ), obteniendo una imagen completa de lo que Googlebot está haciendo en nuestro sitio. El análisis de registros puede ser tedioso y costoso para muchas personas, por eso me gustaría compartir con ustedes una forma de rastrear qué URL procesa Googlebot en Google Analytics.
[Estudio de caso] Administrar el rastreo de bots de Google
Lea el estudio de casoSeguimiento de URL renderizadas por Google
El método es relativamente simple, al menos para cualquier equipo de desarrollo y para cualquier webmaster acostumbrado a trabajar con PHP o similar. Tiene 3 pasos:
- Añadir código javascript
El código detectará cuando Googlebot haya ejecutado Javascript de la misma manera que lo haría un usuario normal, y cargará una imagen usando Javascript (un píxel transparente). - Configuración del servidor
Configure el servidor para ejecutar un archivo PHP (o cualquier otro lenguaje de programación utilizado en el backend) cuando se solicite la URL del píxel transparente. - Enviar los datos a Google Analytics
Nuestro archivo PHP comprobará si Googlebot es realmente Googlebot y, de ser así, enviará los datos a Google Analytics.
Añadir código javascript
En diferentes experimentos que probé, verifiqué que Googlebot ejecutará Javascript solo cuando el código Javascript no necesite la interacción del usuario. Por ejemplo, Googlebot ejecutará cualquier código Javascript que se active con los eventos onload o onready. En este ejemplo, vamos a crear una función que se disparará con el evento onLoad, es decir, cuando se carguen todos los elementos de la página.
Esta función verificará si el User Agent contiene alguno de los bots conocidos de Googlebot y, de ser así, cargará una imagen (un píxel transparente), que llamaremos TransparentPixelGooglebot.gif
<script>
ventana.addEventListener("cargar", función(){
var botPattern = "googlebot|Googlebot-Mobile|Googlebot-Image|Google favicon|Mediapartners-Google";
var re = new RegExp(botPattern, 'i');
var agenteusuario = navigator.usuarioAgente;
if (re.prueba(usuarioAgente)) {
var cliente = nuevo XMLHttpRequest();
var trackRenderURL='https://www.mecagoenlos.com/TransparentPixelGooglebot.gif?OriginUrl='+window.ubicación.href;
cliente.open('GET',trackRenderURL);
client.setRequestHeader('Content-Type', 'text/plain;charset=UTF-8');
cliente.enviar(nulo);
}
});
</script> Cada vez que Googlebot acceda y ejecute Javascript, nuestra función se activará, cargando la imagen “TransparentPixelGooglebot.gif”, agregando a la URL de la imagen algunos parámetros donde especificaremos la URL específica a la que se ha accedido.En esta variable compondremos la URL completa que se solicitará para cargar nuestra imagen “TransparentPixelGooglebot.gif”, donde agregaremos la URL a la que se accede así como el User Agent que la solicita.
var trackRenderURL='https://www.mecagoenlos.com/TransparentPixelGooglebot.gif?OriginUrl='+window.ubicación.href;
Configuración del servidor (.htaccess)
Nuestro siguiente paso es configurar nuestro servidor para que cada vez que se solicite la URL del píxel (TransparentPixelGooglebot.gif), se ejecute un archivo PHP (GooglebotRenderJS.php)
Para hacer esto, tenemos que hacer algunos cambios en nuestro archivo .htaccess (ya que estamos usando un servidor Apache y PHP como lenguaje de programación backend)
Estas dos líneas específicas son las que harán que eso suceda:
RewriteCond %{REQUEST_URI} TransparentPixelGooglebot.gif
RewriteRule TransparentPixelGooglebot.gif(.*)$ https://www.mecagoenlos.com.com/GooglebotRenderJS.php$1Como puede adivinar, los parámetros incluidos con la solicitud de píxel se propagan para que el archivo PHP (GooglebotRenderJS.php) pueda "leerlos".
Datos de seguimiento³
Aprende másEnvía los datos a Google Analytics desde el archivo PHP
En nuestro último paso, creamos el archivo PHP (GooglebotRenderJS.php) que se ejecutará cada vez que se solicite el píxel (TransparentPixelGooglebot.gif).
Este archivo:
- Verifique, usando DNS inverso, si la solicitud fue realmente realizada por Googlebot o un Googlebot falso usando el agente de usuario de Googlebot.
- Identificar qué tipo de bot es (Googlebot Móvil, Imágenes, Anuncios, etc.)
- Enviar los datos a Google Analytics (usando el protocolo de medición de Google Analytics) dentro de un evento donde asignaremos las siguientes variables:
- Categoría de evento: "GoogleRenderFromHtaccess"
- Acción de evento: URL renderizada (la referencia de la solicitud de píxel)
- Etiqueta de evento: una cadena que concatena el agente de usuario, la IP y si el bot es Googlebot real ("Real") o uno falso ("Falso"). Los mando a los tres a GA para poder ver si la identificación de Googlebot funciona correctamente.
- *Importante: almacené la IP solo por un par de días para probar si todo funcionaba correctamente, dejé de hacerlo después por si hay algún problema con las leyes de protección de datos.
<?php
header("Pragma-directiva: no-cache");
header("Caché-directiva: no-cache");
header("Control de caché: sin caché");
header("Pragma: sin caché");
encabezado ("Caduca: 0");
si ($_GET["OrigenUrl"])
$src=$_GET["OrigenUrl"];
demás
$origen = $_SERVIDOR['HTTP_REFERER'];
$UA=$_SERVIDOR["HTTP_USER_AGENT"];
$RenderParameters=$_GET["RenderParameters"];
función GoogleCheker($IP){
# para evitar búsquedas innecesarias, solo verifique si el UA coincide con uno de
# los bots que nos gustan
$nombre de host=gethostbyaddr($IP);
$ip_by_hostname=gethostbyname($nombredehost);
if(preg_match("/googlebot/i",$nombre de host))
si ($ip_by_hostname == $IP)
devolver verdadero;
demás
falso retorno;
demás
falso retorno;
}
función GoogleChekerExtend($Ip){
# para evitar búsquedas innecesarias, solo verifique si el UA coincide con uno de
# los bots que nos gustan
$nombre de host=gethostbyaddr($IP);
$ip_by_hostname=gethostbyname($nombredehost);
if(preg_match("/\.google\.com[\.]?$/i",$nombre de host))
si ($ip_by_hostname == $IP)
devolver verdadero;
demás
falso retorno;
demás
falso retorno;
}
$nombrebot="Inicio";
$bots = array('Mediapartners-Google[ /]([0-9.]{1,10})' => 'Google Mediapartners',
'Mediapartners-Google' => 'Google Mediapartners',
'Googl(e|ebot)(-Imagen)/([0-9.]{1,10})' => 'Imagen de Google',
'Googl(e|ebot)(-Imagen)/' => 'Imagen de 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',
'Móvil.*Googlebot' => 'Google-Móvil',
'^AdsBot-Google' => 'Google-AdsBot',
'^Feedfetcher-Google' => 'Google-Feedfetcher',
'compatible; Google Escritorio' => 'Google Escritorio',
'Googlebot' => 'Googlebot');
foreach ($bots como $patrón => $bot) {
if (preg_match('#'.$patrón.'#i', $UA) == 1)
{
$nombrebot = preg_replace ("/\\s{1,}/i" , '-' , $bot );
romper;
}
}
si (GoogleCheker($_SERVER['REMOTE_ADDR']))
$esGoogle="Real";
elseif(GoogleChekerExtend($_SERVER['REMOTE_ADDR']))
$isGoogle="Extender";
demás
$esGoogle="Falso";
rastreador de bots de clase {
pista de funciones estáticas ($s, $parámetros){
$bot = "";
$datos = matriz(
'v' => 1,
'tid' => 'UA-XXXXXXX-1',
'cid' => self::generar_uuid(),
't' => 'evento',
'dh' => $s['HTTP_HOST'],
'dl' => $s['SOLICITUD_URI'],
'dr' => $s['HTTP_REFERER'],
'dp' => $s['SOLICITUD_URI'],
'dt' => $parámetros['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'], //eliminar después de la prueba
//'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle'] ,
'ea' => $parámetros['RenderedURL']
);
$url = 'http://www.google-analytics.com/collect';
$contenido = http_build_query($datos);
$ch = curl_init();
curl_setopt($ch, CURLOPT_USERAGENT, $s['HTTP_USER_AGENT']);
curl_setopt($canal, 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, $contenido);
$resultado = curl_exec($ch);
$info= curl_getinfo($ch);
curl_close($ch);
}
función privada estática generar_uuid() {
volver 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));
?>
Comprobar si nuestra configuración funciona en Google Analytics
¡Todo está configurado! Ahora podemos comprobar si todo funciona como se esperaba. Para ello, podemos utilizar el informe en tiempo real de Google Analytics y seleccionar el informe “Eventos”. En otra pestaña, abrimos Search Console, vamos a la propiedad de nuestro sitio web y usamos el URL Inspector para obligar a Google a rastrear y renderizar cualquiera de nuestras URL. Si todo funciona, verá nuevos eventos en el informe de eventos en tiempo real de Google Analytics.
Como verá, estos eventos no se contarán como usuarios activos en nuestro sitio, porque el evento está configurado con el parámetro "nonInteraction".
Si hacemos clic en la categoría de evento “GoogleRenderFromHtaccess”, podremos ver el User Agent, la IP y si el bot ha sido identificado como Real o Fake.
Errores de seguimiento generados por Google al intentar mostrar una URL
Ya hemos visto cómo podemos rastrear y verificar qué URL está procesando Google. Pero podemos ir más allá y rastrear qué errores de Javascript se generan cuando Google intenta mostrar las URL de nuestro sitio.
Cuando se procesa Javascript, se pueden generar errores que solo son visibles en el navegador del usuario (y no en nuestro servidor), por lo que hacer un seguimiento de esos errores no es una tarea fácil.
Hoy en día, si queremos comprobar qué errores de Javascript se generan cuando Googlebot procesa nuestras URL, solo podemos hacerlo usando el URL Inspector en Search Console.
- Inspeccionar una URL:
- Haga clic en "Probar URL en vivo":
- Compruebe si hay algún error:
Hacer esto manualmente para muchas URL es mucho trabajo, pero podemos usar el código que acabo de mostrar para rastrear si hay errores de Javascript cuando Googlebot intenta procesar nuestras URL.
Ejemplo de un error generado a propósito para comprobar si el código funciona:
Añadir código Javascript
De la misma manera que hicimos en el ejemplo anterior, capturaremos cualquier error de Javascript usando esta línea de código: "window.addEventListener('error', function(e)" .
Cada vez que se genere un error, se ejecutará una función que nos permitirá guardar esos errores y enviarlos a Google Analytics. Esto será muy similar a lo que hicimos en el ejemplo anterior con la advertencia de que esta función solo se ejecutará cuando haya un error de Javascript.
ventana.addEventListener('error', function(e) {
var botPattern = "googlebot|Googlebot-Mobile|Googlebot-Image|Google favicon|Mediapartners-Google";
var re = new RegExp(botPattern, 'i');
var agenteusuario = navigator.usuarioAgente;
if (re.prueba(usuarioAgente)) {
var cliente = nuevo 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));
cliente.open('GET',ErrorsURLPixel);
client.setRequestHeader('Content-Type', 'text/plain;charset=UTF-8');
cliente.enviar(e);
}
});
Este código ejecutará la función que cargará otro píxel transparente (TransparentPixelGooglebotError.gif), agregando como parámetros la URL que se está procesando, el error y el User Agent, generando una solicitud a una URL como esta:
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));
Configuración del servidor (.htaccess)
De la misma manera que en el ejemplo anterior, agregaremos algunas reglas en el .htaccess para detectar cuándo se carga el píxel y ejecutar un archivo PHP:
RewriteCond %{REQUEST_URI} TransparentPixelGooglebotError.gif
RewriteRule TransparentPixelGooglebotError.gif(.*)$ https://modelode.com/GooglebotErrorRenderJS.php$1 De esa forma, cada vez que se solicite “https://www.mecagoenlos.com/TransparentPixelGooglebotError.gif” se ejecutará el archivo PHP “GooglebotErrorRenderJS.php”.
Archivo PHP
Este archivo PHP verificará si Googlebot es real y enviará los datos a Google Analytics usando un evento con la categoría "ErrorsGoogleRender", usando la URL representada como la Acción del evento y el error en sí mismo como la etiqueta del evento.
<?php
header("Pragma-directiva: no-cache");
header("Caché-directiva: no-cache");
header("Control de caché: sin caché");
header("Pragma: sin caché");
encabezado ("Caduca: 0");
si ($_GET["OrigenUrl"])
$src=$_GET["OrigenUrl"];
demás
$origen = $_SERVIDOR['HTTP_REFERER'];
$UA=$_SERVIDOR["HTTP_USER_AGENT"];
$RenderParameters=$_GET["RenderParameters"];
$textError=$_GET["textError"];
$lineError=$_GET["LineError"];
función GoogleCheker($IP){
# para evitar búsquedas innecesarias, solo verifique si el UA coincide con uno de
# los bots que nos gustan
$nombre de host=gethostbyaddr($IP);
$ip_by_hostname=gethostbyname($nombredehost);
if(preg_match("/googlebot/i",$nombre de host))
si ($ip_by_hostname == $IP)
devolver verdadero;
demás
falso retorno;
demás
falso retorno;
}
función GoogleChekerExtend($Ip){
# para evitar búsquedas innecesarias, solo verifique si el UA coincide con uno de
# los bots que nos gustan
$nombre de host=gethostbyaddr($IP);
$ip_by_hostname=gethostbyname($nombredehost);
if(preg_match("/\.google\.com[\.]?$/i",$nombre de host))
si ($ip_by_hostname == $IP)
devolver verdadero;
demás
falso retorno;
demás
falso retorno;
}
$nombrebot="Inicio";
$bots = array('Mediapartners-Google[ /]([0-9.]{1,10})' => 'Google Mediapartners',
'Mediapartners-Google' => 'Google Mediapartners',
'Googl(e|ebot)(-Imagen)/([0-9.]{1,10})' => 'Imagen de Google',
'Googl(e|ebot)(-Imagen)/' => 'Imagen de 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',
'Móvil.*Googlebot' => 'Google-Móvil',
'^AdsBot-Google' => 'Google-AdsBot',
'^Feedfetcher-Google' => 'Google-Feedfetcher',
'compatible; Google Escritorio' => 'Google Escritorio',
'Googlebot' => 'Googlebot');
foreach ($bots como $patrón => $bot) {
if (preg_match('#'.$patrón.'#i', $UA) == 1)
{
$nombrebot = preg_replace ("/\\s{1,}/i" , '-' , $bot );
romper;
}
}
si (GoogleCheker($_SERVER['REMOTE_ADDR']))
$esGoogle="Real";
elseif(GoogleChekerExtend($_SERVER['REMOTE_ADDR']))
$isGoogle="Extender";
demás
$esGoogle="Falso";
rastreador de bots de clase {
pista de funciones estáticas ($s, $parámetros){
$bot = "";
$datos = matriz(
'v' => 1,
'tid' => 'UA-XXXX-1',
'cid' => self::generar_uuid(),
't' => 'evento',
'dh' => $s['HTTP_HOST'],
'dl' => $s['SOLICITUD_URI'],
'dr' => $s['HTTP_REFERER'],
'dp' => $s['SOLICITUD_URI'],
'dt' => $parámetros['page_title'],
'ck' => $s['HTTP_USER_AGENT'],
'uip' => $s['REMOTE_ADDR'],
'ni' => 1,
'ec' => 'ErroresGoogleRender',
'el' => $params['textError']." (line:".$params['lineError']") - ".$params['UA']." - " .$params['botname' ]." - ".$params['isGoogle']."- ip: ".$s['REMOTE_ADDR'], //eliminar después de la prueba
//'el' => $params['UA']." - ".$params["RenderParameters"]." -" .$params['botname']." - ".$params['isGoogle'] ,
'ea' => $parámetros['RenderedURL']
);
$url = 'http://www.google-analytics.com/collect';
$contenido = http_build_query($datos);
$ch = curl_init();
curl_setopt($ch, CURLOPT_USERAGENT, $s['HTTP_USER_AGENT']);
curl_setopt($canal, 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, $contenido);
$resultado = curl_exec($ch);
$info= curl_getinfo($ch);
curl_close($ch);
}
función privada estática generar_uuid() {
volver 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));
?>
Ahora ya podemos ver qué errores de Javascript están ocurriendo cuando Google intenta renderizar nuestras URL.
Enviar datos a Google Analytics desde nuestro archivo PHP
Con esta implementación, podemos ver qué errores específicos de Javascript se generan cuando Google intenta mostrar nuestras URL y en qué URL específicas están ocurriendo.
Tengo en mente mucha otra información para rastrear con respecto al proceso de renderizado de Google, como verificar si Googlebot está intentando algunas interacciones (como desplazamiento, un clic o cualquier otro evento de Javascript), pero lo dejaré para otra publicación. ¡Espero que les haya gustado!