Setting up the Segment

This all gets built up in what can feel very cumbersome. Check out ?segment_ga4() for the documentation of how the segment gets built. Correctly, it describes this as a “hierarchy.” In practical terms, though, we build from the bottom up:

1. Define a segment element using segment_element(). This is just a single conditional statement.
2. Combine one or more segment elements together into a segment vector using segment_vector_simple(). There are a few options here, but we’re going to stick with the simple approach. And, it’s still going to feel redundant, because we’re only including a single segment element.
3. Combine one or more segment vectors into a segment definition using segment_define(). This may feel like it’s the same as the previous step, but, if you think about the segment builder in the web interface, it will start to make sense – there are two levels at which can combine multiple “things” together to define a segment. Alas! Here, again, we’re just including a single segment vector, so it all feels really cumbersome.
4. Put that into a segment object, which is what we’re actually going to use in the data. We actually give the segment a name here that will be returned in the results.
5. Actually pull the data, passing in the segment object as an argument.

In addition to the “hierarchy” messiness for a simple segment, there is also some list() messiness. Note, for instance, how my_segment_vector in the example code includes a list within a list. Use this example (and other examples on this site) as well as the ?segment_ga4() documentation to troubleshoot.

Processing the List

As Mark Edmondson says, “If you’re going to use R effectively, you’re going to have to learn to love lists.” There are a couple of things to note about how we’re using lists in this code:

1. We set up a vector with the three different deviceCategory values. To get even more advanced, we could actually have one query that pulls all of the values for deviceCategory (or some other dimension) and then use the results of that category to get the list of values we actually want to process. Minds start to get blown at that point (but it’s a very practical application!).
2. We use map() (which is from the purrr package in the Tidyverse) to call our function for each of those values. This will return a list of data frames – one data frame for each device category. We’ll then process that list for our data visualization(s)!

Now…onto the code!

The Data Pulling Code

#############
# Create a function that takes in a device category value, builds a dynamic segment using that
# value, and then queries the data.
#############

get_data <- function(device_category){
  
  # Build the segment name
  my_segment_name <- paste(device_category,"Sessions")
  
  # Create a segment element object. See ?segment_element() for details.
  my_segment_element <- segment_element("deviceCategory", 
                                        operator = "EXACT",
                                        type = "DIMENSION",
                                        expressions = device_category) # The value passed to the function
  
  # Create a segment vector that has just one element. See ?segment_vector_simple() for details. Note
  # that the element is wrapped in a list(). This is how you would include multiple elements in the
  # definition.
  my_segment_vector <- segment_vector_simple(list(list(my_segment_element)))
  
  # Define the segment with just the one segment vector in it. See ?segment_define() for details.
  my_segment_definition <- segment_define(list(my_segment_vector))
  
  # Create the actual segment object that we're going to use in the query. See ?segment_ga4()
  # for details.
  my_segment <- segment_ga4(my_segment_name,          # We built this at the beginning of the function
                            session_segment = my_segment_definition)

  # <whew>!!!
  
  # We're only going to return the top 10 values, so we need to order the results in descending order.
  # This *could* be defined outside the function, but, for readability, we're putting it here.
  results_order <- order_type("pageviews",
                              sort_order = "DESCENDING",
                              orderType = "VALUE")
  
  # Pull the data. See ?google_analytics_4() for additional parameters.
  ga_data <- google_analytics(viewId = view_id,
                                date_range = c(start_date, end_date),
                                metrics = "pageviews",
                                dimensions = "pagePath",
                                order = results_order,
                                segments = my_segment,
                                max = 10)
  
  # Go ahead and print to the console that this step has been completed. This is useful both
  # for debugging, as well as to be able to track progress as the script is running.
  cat("Completed pulling data for:", device_category, "\n")
  
  # The function will return the last value set, so repeat ga_data to ensure that happens
  ga_data
  
}

#############
# Put that function to use!
#############

# Define the list of values to be processed
device_categories <- c("Mobile", "Tablet", "Desktop") 

# And then process it! It's an innocuous little line of code, but it's where the magic happens!
page_data <- map(device_categories, get_data) 

# The above returns a list of three data frames -- one for each device category. For our data
# check, we'll just peek at the Mobile values
head(page_data$Mobile)