SEO-Monitoring mit Crawlabgleichen in R – 2020 Version

Bekanntlich ist es sinnvoll eine Website während der Umsetzung des SEO-Konzepts sowie im Rahmen der Betreuung genaustens im Auge zu behalten. Eine der mächtigsten Instrumente um immer auf dem neusten Stand zu sein, ist das zeitversetzte Crawlen und Abgleichen der Website basierend auf der URL Basis. Um den regelmäßigen Zeitaufwand dafür auf ein Minimum zu reduzieren, werden wir in diesem Beitrag alles vom Crawling bis zum Output-Excel automatisieren! Anders ausgedrückt, das Einzige was zu tun ist neben der initialen Einrichtung, ist die intellektuelle Analyse des Ausgabe-Excel.

Da unser letzter Blog-Beitrag zu diesem Thema schon einige Zeit her ist und wir uns bei [Get:Traction] natürlich auch ständig weiterentwickeln, ist es an der Zeit, mal wieder ein Update zu lancieren! Optimierung ist schließlich der Inbegriff unserer Kernkompetenz.

Der Output – Was kommt dabei raus?

Um abzuklären, ob der Crawlabgleich etwas für Dich ist, ist es sinnvoll zuerst einmal einen Blick auf den Output zu werfen:

Das Endergebnis ist nach wie vor eine Excel Datei, welche in einem Reiter für jede Metrik die Unterschiede zum vorherigen Crawl aufzeichnet. Dabei sind folgende Punkte abgedeckt:

• Neue URLs
• Nicht mehr verlinkte URLs
• Änderungen bei URLs, die in beiden Crawls vorhanden sind:
  • Status Codes
  • Canonical-Anweisungen
  • Meta Robots
  • H1
  • Titles
  • Descriptions
  • Content Types
  • Klicktiefe
  • Dateigröße

Übersicht der Arbeitsschritte

Grundsätzlich haben wir 3 Schritte während des gesamten Prozesses:

– Wir crawlen die Website in Zeitabständen

– Wir vergleichen die Crawls miteinander

– Wir analysieren das Endergebnis

Crawlen der Website

Für diesen Arbeitsschritt benötigen wir die Screaming-Frog SEO Spider.

Erstellen der Ordnerstruktur und Einrichtung der Crawl-Jobs im Aufgabenplaner

Um unseren Export nach beliebigen Zeitabständen zu automatisieren und damit regelmäßig viel Zeit zu sparen, legen wir eine standardisierte Ordnerstruktur an und erstellen im Windows Aufgabenplaner Jobs für das Crawling.

Ordnerstruktur

Initial benötigen wir 4 Ordner, die alle im gleichen Verzeichnis abzulegen sind:

Die Struktur sieht folgendermaßen aus:

• 01_crawl_abgleiche
  • /[Kunde]
    • Hier kommen die vom R-Skript generierten XLSX rein.
• 02_sf_exports
  • /[Kunde]
    • /[yyyy.mm.dd.hh.mm.ss]
      • Hier legt der Screaming Frog automatisch seine Exporte ab. Zum einen den „internal_all.csv“. Zum anderen – um im Nachhinein im Detail nachsehen zu können – den gesamten Crawl als „.seospider“.
• 03_sf_configs
  • Hier liegen die Screaming-Frog Konfigurationsdateien ab (sofern vorhanden).
• 04_R
  • /[R-Projekt]
    • Hier liegt das „.R“-Projekt, welches aus den letzten beiden Crawls für eine Website den Abgleich bastelt und diesen in „01_crawlabgleiche/[Kunde]/“ abglegt.

Alle fett geschriebenen Ordner in der obigen Darstellung müssen einmal initial angelegt werden. Der Rest wird automatisch von unserem Skript und dem SF generiert.

Windows Job für Crawls

1. Erstellen der 4 initialen Ordner.
2. Erstellen eines Ordners für jeden Kunden unter 02_sf_exports.
3. Wenn Screaming-Frog Konfigurationsdateien für die vorgesehenen Crawls vorhanden sind, diese im Ordner „03_sf_configs“ ablegen.
4. Öffne die „Aufgabenplanung“ über die Windows-Suche.
5. Es ist empfehlenswert einen neuen Ordner für die Crawlings sowie die R-Jobs in der Aufgabenplanung zu erstellen:

6. Navigiere in den neu erstellten Ordner
7. Erstelle mit Rechtsklick -> „Neue Aufgabe erstellen“ eine neue Aufgabe
8. Im Dialogfeld müsst ihr dem Job nun einen Namen geben (Hier empfiehlt es sich die Namensgebung zu standardisieren und das Intervall mit einzubeziehen z.B. „1month_kunde“. Unter dem Reiter „Trigger“ könnt ihr das gewünschte Intervall und die Ausführungstage festlegen. Wir crawlen bspw. wöchentlich. Das sähe dann so aus:Navigiere in den neu erstellten Ordner
9. Erstelle mit Rechtsklick -> „Neue Aufgabe erstellen“ eine neue Aufgabe
10. Im Dialogfeld müsst ihr dem Job nun einen Namen geben (Hier empfiehlt es sich die Namensgebung zu standardisieren und das Intervall mit einzubeziehen z.B. „1month_kunde“. Unter dem Reiter „Trigger“ könnt ihr das gewünschte Intervall und die Ausführungstage festlegen. Wir crawlen bspw. wöchentlich. Das sähe dann so aus:

9. Im Reiter Aktion legen wir nun den Job folgendermaßen an:

• Kopiert euch den Pfad der „ScreamingFrog CLI“ mittels „Shift-Rechtsklick“ -> „Als Pfad kopieren“
• („C:\Program Files (x86)\Screaming Frog SEO Spider\ScreamingFrogSEOSpiderCli.exe“)
• Klickt auf „Neu“ und tragt den Kopierten Pfad im Feld „Programm/Skript“ ein
• Kopiert nun in das Feld „Argumente hinzufügen“ folgenden Text:

–project-name Kunden_Crawlabgleiche –task-name 1month_tue_1200_kunde –crawl „https://www.beispiel.de/“ –config „C:\03_sf_configs\kunde.seospiderconfig“ –headless –output-folder „C:\02_sf_exports\kunde“ –timestamped-output –save-crawl –export-tabs Internal%3AAll –export-format csv

• Ersetzt nun alle fett markierten Stellen im Text durch eure eigenen Angaben.
  • Kunden_Crawlabgleiche ist der Projektname im Screaming-Frog. Kann dort angelegt werden. (Optionaler Parameter)
  • 1_month_tue_1200_[kunde] ist der Name des Tasks im Screaming-Frog.
  • Die URL ist die zu crawlende website
  • Die beiden Pfade geben einmal den Ort der zu nutzenden SF-Config für den Crawl an und den Output Folder. Hier muss der Pfad in den jeweiligen Kunden Ordner unter /02_sf_exports rein.
• Eine Dokumentation zu den genutzten Parametern findet sich hier.

Das Endergebnis sieht dann so aus:

Jetzt könnt Ihr auf OK klicken und den Job speichern. Damit haben wir unseren automatisierten Crawl!

Abgleichen der Websites

Für diesen Arbeitsschritt benötigen wir R Studio. Hier eine kurze Anleitung und Erklärung zur Installation.

Anlegen des R-Skripts und Erstellen von Windows-Jobs

Anlegen des R-Skripts

• Ladet euch den Ordner hier von unserem Git-Hub herunter.
• Hier befinden sich 2 Dateien („website_change_monitor.R“ und „FUNS.R“)
• Öffnet R Studio und legt ein neues R-Project im Ordner /04_R/ an.
• Kopiert jetzt die beiden Dateien aus dem Download in euren Projektordner („/04_R/[Projektname]/“)

Jetzt müssen wir nur noch 2 Pfade im R Skript anpassen und schon haben wir alles für unseren Windows Job vorbereitet!

Navigiert hierzu in R Studio in eurem Projekt in die Datei „website_change_monitor.R“ und passt folgende Variablen an:

PATH_TO_XLSX_EXPORTS ist der Pfad in euren /01_crawl_abgleiche Ordner.

PATH_TO_SF_EXPORTS ist der Pfad in euren /02_sf_exports Ordner.

(Tipp: Um auf der sicheren Seite zu sein könnt ihr „C:/“ eingeben und dann mit TAB und den Pfeiltasten bis in den jeweiligen Ordner navigieren)

Speichert das Skript jetzt mit „STRG & S“.

Damit das Skript funktioniert müsst ihr ein paar R Packages installieren. Das geht ganz einfach indem ihr am oberen Rand in R Studio auf den hints „install“ durchklickt. Sollten die Meldungen nicht aufpoppen, könnt ihr alle Packages folgendermaßen installieren:

install.packages(„[package]“)

Als Beispiel einmal:

install.packages(„tidyverse“)

Die Namen aller benötigten Packages findet ihr unter #1 Libraries (alle die mit „library()“ geladen werden) im Skript.Die Namen aller benötigten Packages findet ihr unter #1 Libraries (alle die mit „library()“ geladen werden) im Skript.

Anlegen des Windows-Jobs für das R-Skript

1. Legt euch wieder im Aufgabenplaner einen neuen Ordner für R an.
2. Erstellt hier eine neue Aufgabe mit Namen und Trigger. Der Trigger sollte natürlich nach dem ausführen der Crawl Jobs gesetzt werden.
3. Gebt im Feld „Programm/Skript“ den Pfad zu eurer R-Installation ein, ungefähr so: „C:\Program Files\R\R-3.6.1\bin\Rscript.exe“
4. Im Feld „Argumente hinzufügen“ geben wir nun den Dateinamen des R-Skripts an: „website_change_monitor.R“
5. Im Feld „Starten in“ geben wir den Pfad des Ordners an, in dem sich das Skript befindet: „/04_R/[Projektname]/“
6. Jetzt können wir den Job speichern!

Das wars! Jetzt haben wir einen völlig automatisierten Crawlabgleich. Zur Einrichtung eines weiteren Abgleichs, müsst ihr nur einen Ordner für den neuen Kunden in 02_sf_exports erstellen und einen Crawl-Job im Windows Aufgabenplaner erstellen. Das Skript registriert den neuen Kunden von alleine. Eure Output-Excels findet ihr nun im Ordner /01_Crawl_Abgleiche/.

Das Skript in allen Einzelheiten

Libraries

Hier werden die zum Ausführen des Skripts benötigten R-Packages geladen. Um diese beim Ausführen des Skripts nutzen zu können, müsst ihr diese vorher installieren (Beschrieben in Punkt Anlegen des R-Skripts).

# Libraries -------------------------------------------
options(java.parameters = "-Xmx8g")
library(tidyverse)
library(xlsx)
library(slackr)
library(lubridate)
source("FUNS.R")

Vars

Hier werden die Pfade für die Imports und Exports festgelegt. Zusätzlich legen wir hier unseren Slack API Key als Variable (Auskommentiert da nicht essenziell) an, um erfolgreich ausgeführte Scripts sowie Fehlermeldungen in unseren Scripts- Slack Channel automatisiert zu pushen! Damit hat man also auch ein Warnsystem implementiert. Die Variable „#TESTING_WEBSITE“ ist standardmäßig auskommentiert mit einem #. Sollte man Adhoc nur eine einzige Website vergleichen wollen, kann man hier das # entfernen und in die Gänsefüßchen die Website schreiben. Dabei einfach den Namen des Ordners verwenden, wie ihr ihn im sf_exports Verzeichnis erstellt habt.

# VARS ------------------------------------------------
PATH_TO_XLSX_EXPORTS <- "C:/01_crawl_abgleiche"
PATH_TO_SF_EXPORTS <- "C:/02_sf_exports"
#TESTING_WEBSITE <- ""
#SLACK_API_KEY <- ""

Slack

Hier wird dem „slackR“ Package die nötige Information mitgegeben. Den API Key, in welchen Channel soll gepusht werden? Unter welchem Namen sollen die Nachrichten dort auftauchen?

Die Sektion ist im download-Skript ebenfalls auskommentiert, da die Nutzung von SlackR natürlich nicht obligatorisch ist.

# Slack -----------------------------------------------
#slackr_setup(api_token = SLACK_API_KEY,
#             channel = "#scripts",
#             username = "[R] Crawl-Abgleich",
#             echo = FALSE)

Get Files

Find all CSV’s

Hier werden alle Dateien mit .csv-Endung rekursiv aus dem in der Variable PATH_TO_SF_EXPORTS enthaltenen Pfad aufgelistet.

# Get-files -------------------------------------------
## Find all CSVs
files <- list.files(PATH_TO_SF_EXPORTS,
                    full.names = TRUE,
                    recursive = TRUE,
                    pattern = "\\.csv")

Split paths

Nun splitten wir die Pfade der aufgelisteten Dateien in dem Dataframe „df_file_paths“ in einzelne Spalten auf.

## Split paths
df_file_paths <- tibble(path = files) %>%
  splitstackshape::cSplit(splitCols = "path",
                          drop = FALSE,
                          sep = "/",
                          direction = "wide",
                          type.convert = FALSE) %>%
  as_tibble()

Extract website, datetime

Hier determinieren wir, welche Teile der in „df_file_paths“ enthaltenen Pfade welches Element sind und geben den entsprechenden Spalten die Namen.

## Extract website, datetime
select_cols <- c(1, ncol(df_file_paths) - 2, ncol(df_file_paths) - 1)
df_file_paths <- df_file_paths[ , select_cols]
names(df_file_paths) <- c("path", "website", "datetime")

Convert to date

Hier konvertieren wir das bisher als Character zu verstehende Datum in der Spalte „datetime“ in ein richtiges Datums-Datenformat. Dazu nutze ich die äußerst nutzvolle Library Lubridate.

## Convert to date
df_file_paths <- df_file_paths %>%
  mutate(datetime = ymd_hms(datetime),
         date = date(datetime))

Check if two Crawls exist

Wir gruppieren nach der Spalte „website“ und zählen, ob die Anzahl an Elementen pro Gruppe mehr als 1 beträgt. Anschließend lösen wir die Gruppierung wieder auf.

## Check if two crawls exist
df_file_paths <- df_file_paths %>%
  group_by(website) %>%
  filter(n() > 1) %>%
  ungroup()

Get last two crawls

Wir gruppieren abermals nach „website“ und fügen dem Dataframe die Spalte „date_rank“ hinzu. Dieser wird mithilfe der rank() Funktion absteigend durch die Spalte „datetime“ berechnet. Abschliessend filtern wir auf Einträge mit „date_rank“ 1 & 2 und lösen die Gruppierung wieder auf.

## Get last two crawls
df_file_paths <- df_file_paths %>%
  group_by(website) %>%
  mutate(date_rank = rank(desc(date))) %>%
  filter(date_rank %in% c(1, 2)) %>%
  ungroup()

Get Website for iteration

Um für jede Website einen einzelnen Crawl Abgleich bauen zu können, müssen wir jede Website als einzelnes Objekt einer Liste betrachten und die gleichen Aktionen für jedes Objekt in dieser Liste iterativ durchführen. Hierzu bedienen wir uns eines einfachen for()-loops. Diese Liste bereiten wir nun mithilfe der unique-Funktion vor. Diese gibt uns, nach Einspeisung der Spalte „websites“ aus „df_file_paths“, einen Vector ohne doppelte Werte zurück. Sprich – wir haben eine Liste aller unserer Websites, die als Iterationsobjekt benutzt werden können.

## Get websites for iteration
websites <- unique(df_file_paths$website)

Filter for testing

Bevor wir mit dem eigentlichen Abgleich loslegen, gucken wir hier nach, ob die vorher angesprochene Variable „TESTING_WEBSITE“ besteht und wenn ja, filtern nur auf die dort enthaltene Website.

## Filter for testing
if (exists("TESTING_WEBSITE")) websites <- TESTING_WEBSITE

Compare Crawls

Wir iterieren über unseren „websites“ vector und führen für jede enthaltene Website folgende Aktionen aus:

Am Anfang des Loops reduzieren wir das in dieser Iteration behandelte Datenset auf die Daten einer einzigen Website und setzen temporäre Variablen für das neue und alte Crawldatum. Wir geben eine Message in der Console aus und lesen beide Crawls, mithilfe der in „FUNS.R“ definierten Funktion „read_crawl“, ein. Dazu fügen wir eine Spalte mit neuem/altem Datum an.

for (WEBSITE in websites) {
  try_res <- tryCatch({
    df_website_file_paths <- df_file_paths %>%
      filter(website == WEBSITE)
    CRAWL_NEW_DATE <- max(df_website_file_paths$date)
    CRAWL_OLD_DATE <- min(df_website_file_paths$date)
    message("\n\n[", WEBSITE, "] ", strrep("*", 40), "\n\n~ Read crawls\n")
    crawl_new <- read_crawl(df_website_file_paths[df_website_file_paths$date == CRAWL_NEW_DATE, "path"][[1,1]]) %>%
      mutate(date = CRAWL_NEW_DATE)
    crawl_old <-read_crawl(df_website_file_paths[df_website_file_paths$date == CRAWL_OLD_DATE, "path"][[1,1]]) %>%
      mutate(date = CRAWL_OLD_DATE)

Create website-dir if not exists

Der Kommentar ist ziemlich treffend – wir kreieren (wenn nicht vorhanden) ein Verzeichnis mithilfe des Iterationsobjektes sowie des Pfads aus PATH_TO_XLSX_EXPORTS.

## Create website-dir if not exists
    dir.create(file.path(PATH_TO_XLSX_EXPORTS, WEBSITE),
               showWarnings = FALSE)

Get new (linked) URLs

Abermals eine Message in die Console. Hier filtern wir innerhalb eines Anti-Joins vom neuen auf den alten Crawl, auf URLs, in dessen „content“ Spalte „html“ vorkommt oder die „status“ Spalte dem String „Connection Timeout“ entspricht.

Dabei bleiben nur noch die im neuen Crawl enthaltenen URLs zurück, die im alten nicht mehr existieren. Wir wählen per „select“ aus, welche Spalten wir haben wollen und konvertieren das ganze in ein Dataframe, da die XLSX Library kein Tibble versteht.

    ## Get new (linked) URLs ---------------------------
    message("~ Get new (linked) URLs\n")
    new_urls <- crawl_new %>%
      filter(str_detect(content, "html") | status == "Connection Timeout") %>%
      anti_join(crawl_old %>%
                  filter(str_detect(content, "html") | status == "Connection Timeout"),
                by = "address") %>%
      mutate(is_canonical = (address == canonical_link_element_1 | canonical_link_element_1 == "")) %>%
      select(date,
             address,
             status_code,
             status,
             indexability_status,
             meta_robots_1,
             canonical_link_element_1,
             title_1,
             meta_description_1,
             is_canonical) %>%
      mutate(date = as.character(date)) %>%
      as.data.frame()
# convert to DataFrame as xlsx:: cannot handle tibble()

Get no longer linked/ deleted URLs

Message in die Console. Gleiches Vorgehen wie bei Punkt 4.5.2 Nur hier Anti-joinen wir vom alten auf den Neuen Crawl.

## Get not longer / deleted URLs -------------------
    message("~ Get not longer / deleted URLs\n")
    no_longer_linked_urls <- crawl_old %>%
      filter(str_detect(content, "html") | status == "Connection Timeout") %>%
      anti_join(crawl_new %>%
                  filter(str_detect(content, "html") | status == "Connection Timeout"),
                by = "address")

Get Status Code of not linked/deleted URLs

Message. Hier prüfen wir den Status Code der nicht mehr verlinkten Seiten, da wir ihn ja über den Crawl nicht kennen. Der Grund ist, dass wir prüfen wollen, ob eine Seite korrekterweise nicht mehr verlinkt ist. Antwortet die URL mit „404 Not Found“, ergibt es vollkommen Sinn, sie nicht mehr zu verlinken. Antwortet die Seite hingegen mit „200 OK“, stellt sich die Frage, warum sie nicht mehr verlinkt ist, wenn sie doch erreichbar ist. Im Hintergrund rennt hier ein parallelisierter Status-Code-Fetcher los. Je nachdem, wie viele URLs nicht mehr verlinkt sind, kann die Abfrage durchaus länger dauern. Auf der Console seht ihr aber die gerade abgefragten URLs, sodass ihr zumindest einen groben Überblick habt, dass sich noch etwas tut und dass das Skript nicht hängen geblieben ist. (Anhand dieses Punktes ist unter anderem erkennbar, dass es sinnvoll ist, die Crawls jeweils mit gleicher Konfiguration durchzuführen).

    ## get Status Code of not linked / deleted URLs
    message("~ Get Status Code of not linked / deleted URLs\n")
    urls <- no_longer_linked_urls$address
    if (length(urls) > 0) {
      r <- fetch_multi_urls(urls)
      r_df <- tibble(
        address = unlist(lapply(r, `[[`, "url")),
        status_code_current = unlist(lapply(r, `[[`, "status_code"))
      )
      no_longer_linked_urls <- no_longer_linked_urls %>%
        left_join(r_df, by = "address") %>%
        select(date,
               address,
               status_code,
               status,
               indexability_status,
               status_code_current,
               meta_robots_1,
               canonical_link_element_1,
               title_1,
               meta_description_1) %>%
        rename(status_code_old = status_code) %>%
        mutate(date = as.character(date)) %>%
        as.data.frame()
    }

Get identical URLs

Was wohl 😉. Wir filtern auf HTML URLs beider Crawls und machen uns eines inner-Joins habhaft, um die identischen URLs des Abgleichs zu erhalten. Dazu fügen wir im Datenset Spalten für jedes Detail einer URL an, welche angeben, ob sich der entsprechende Wert geändert hat.

    message("~ Get identical URLs\n")
    identical_urls <- crawl_new %>%
      filter(str_detect(content, "html")) %>%
      inner_join(crawl_old %>%
                   filter(str_detect(content, "html")),
                 by = "address",
                 suffix = c("_new", "_old")) %>%
      mutate(change_status_code = status_code_new != status_code_old,
             change_canonical = canonical_link_element_1_new != canonical_link_element_1_old,
             change_index = meta_robots_1_new != meta_robots_1_old,
             change_title = title_1_new != title_1_old,
             change_description = meta_description_1_new != meta_description_1_old,
             change_content_type = content_new != content_old,
             change_crawl_depth = crawl_depth_new != crawl_depth_old,
             change_h1 = h1_1_new != h1_1_old,
             change_word_count = word_count_new != word_count_old,
             change_indexability = indexability_new != indexability_old,
             change_indexability_status = indexability_status_old != indexability_status_new,
             change_orphan_pages = (is.na(crawl_depth_old) & !is.na(crawl_depth_new)) | (!is.na(crawl_depth_old) & is.na(crawl_depth_new)))

Get identical URL with changes

Da wir nun das Datenset an URLs definiert haben, welches in beiden Crawls enthalten ist, können wir nun die einzelnen Bestandteile dieses Datensets betrachten und vergleichen.

Verwaiste Seiten:

Hier definieren wir, je nach dem, was in unserer Spalte change_orphan_pages, die wir in Punkt 4.5.5 gebildet haben, steht, ob es sich um eine nicht mehr oder neu verwaiste Seite handelt. Dies speichern wir als Dataframe, um es später in der Excel abbilden zu können.

Dieses Vorgehen bleibt für jede Metrik das gleiche. Darum werde ich hier nicht auf jeden Unterpunkt eingehen.

   ## Get identical URLs with changes -----------------
    message("~ Get identical URLs with changes\n")
    ## orphane pages
    message("\tOrphan pages")
    change_orphan_pages <- identical_urls %>%
      filter(change_orphan_pages == TRUE) %>%
      mutate(change = case_when(!is.na(crawl_depth_old) & is.na(crawl_depth_new) ~ "neu verwaist",
                                is.na(crawl_depth_old) & !is.na(crawl_depth_new) ~ "nicht mehr verwaist")) %>%
      select(change,
             address,
             status_code_old,
             status_code_new,
             status_old,
             status_new,
             title_1_old,
             title_1_new) %>%
      as.data.frame()

Get biggest resources

Hier sortieren wir bei Images, JavaScript und CSS, absteigend nach der Größe (size_bytes) und speichern diese als DataFrame.

    ## Get biggest ressources --------------------------
    message("~ Get biggest ressources\n")
    ## images
    message("\tImages")
    top_image <- crawl_new  %>%
      filter(str_detect(content, "image")) %>%
      select(address, size_bytes) %>%
      arrange(desc(size_bytes)) %>%
      as.data.frame()
    ## JavaScript
    message("\tJavaScript")
    top_js <- crawl_new  %>%
      filter(str_detect(content, "javascript")) %>%
      select(address, size_bytes) %>%
      arrange(desc(size_bytes)) %>%
      as.data.frame()
    ## CSS
    message("\tCSS\n")
    top_css <- crawl_new  %>%
      filter(str_detect(content, "css")) %>%
      select(address, size_bytes) %>%
      arrange(desc(size_bytes)) %>%
      as.data.frame()

Create Excel

Hier nutzen wir die Library XLSX, um eine Arbeitsmappe zu erstellen und diese mit unseren sheets in der „sheet_order“ variable und den im Loop erstellten Data-Frames zu befüllen. Mit saveWorkbook() wird dem Export der Pfad übergeben und der Crawlabgleich, mit neuem und altem Datum im Namen, im entsprechenden Ordner der Website abgespeichert.

    ## Create Excel ------------------------------------
    message("~ Write Excel for: [ ", WEBSITE, " ] ", strrep("*", 40), "\n")
    ## set order of sheets here
    sheet_order <- c("new_urls",
                     "no_longer_linked_urls",
                     "change_orphan_pages",
                     "change_status_code",
                     "change_index",
                     "change_canonical",
                     # "change_indexability",
                     # "change_indexability_status",
                     "change_title",
                     "change_description",
                     "change_h1",
                     "change_word_count",
                     "change_content_type",
                     "change_crawl_depth",
                     "top_image",
                     "top_js",
                     "top_css")
    wb <- createWorkbook()
    for (sheet in sheet_order) {
      if (nrow(eval(parse(text = sheet))) > 0)
        add_sheets(wb, sheet)
    }
    saveWorkbook(wb, file.path(PATH_TO_XLSX_EXPORTS,
                               WEBSITE,
                               paste0(CRAWL_NEW_DATE,
                                      "__",
                                      CRAWL_OLD_DATE,
                                      "__",
                                      WEBSITE,
                                      ".xlsx")))

Send Slack notification (Fail, Success)

Zu guter Letzt unsere Slack-Notification. Hier wird eine Message aus dem momentanen Iterationsobjekt und einer vorgefertigten Nachricht zusammengebaut und mithilfe der vorher erstellten Variablen und des Packages SlackR in den Channel gepostet. Alle Slack-Inhalte sind im download-Skript auskommentiert, da die Nutzung von „SlackR“ rein optional ist.

Damit ist der For-Loop abgeschlossen und das Skript erstellt die Crawlabgleiche aller vorhandenen Websites.

Viel Spaß beim Abgleichen! Wenn ihr Fragen oder Anregungen habt, gerne kommentieren oder mir direkt eine Mail schreiben 🙂