• sortedBy="{!v.sortedBy}"
• defaultSortDirection="{!v.defaultSortDirection}"
• sortedDirection="{!v.sortedDirection}"
• onsort="{!c.handleSort}"

1. If the onsort attribute is not filled, nothing will happen.
   • ​​​​You have to define your own sort function. Without this, the table component just logs that it has been sorted. Don't worry though. This isn't as hard as it sounds. The comment by Khan Anas contains a simple sort function which you can also find here: Official Sort Example  (https://developer.salesforce.com/docs/component-library/bundle/lightning:datatable/example#lightningcomponentdemo:exampleDatatableSorting)(if that link ever breaks, just google "lightning:datatable", go to the docs example link and scroll down to the 'Sorting in Data Table' example. I've also included it below.
   • If the user clicks on a column to sort that wasn't previously sorted by, the table will use the defaultSortDirection attribute.
   • ​​​​​​In real terms, this means that if event.getParam('fieldName') does not equal component.get('v.sortedBy'), then event.getParam('sortDirection') will be set to component.get('v.defaultSortDirection')
   • Read the above slower and try it out in some experiments.
     • In other words, if you sort by column 1 and then sort again by column 2, the table will use the defaultSortDirection for sorting by column 2.
     • But if you sort by column 2 again, the table will alternate the sort direction... but only if you've either set both sortedDirection and sortedBy, or neither... which brings me to my next point.
2. If you set sortedBy, you must set sortedDirection as well and vise versa.
   • ​​​​​​Just set these two attributes at the bottom of your handleSort function. That's the simple answer.
   • If you don't set either of these attributes explicitly, the component will automatically set them, but it doesn't know which column you sorted by, so you won't get an indicator arrow on the appropriate column. Also, it doesn't know that you've clicked the same column twice in a row, so it'll always sort using the defaultSortDirection (see point 2).
   • Technically, you can get away with using this method if you update the defaultSortDirection at the bottom of your handleSort function, but... don't do that. It's clunky and doesn't make sense, and whoever reads the code months down the track wil not like you very much - including yourself!
3. Spellcheck your assignments!
   • This sounds simple but it confused me a LOT when I couldn't figure out why it wasn't working.
   • PLEASE NOTE: In particular, the event contains a sortDirection attribute, but the datatable component has a corresponding sortedDirection attribute. sort vs sorted.
4. Make sure your component actually has the appropriate attributes, and that they're linked to the attributes on the datatable itself.
   • Otherwise setting them is pointless and plain won't work.

<aura:component implements="flexipage:availableForAllPageTypes" 
                controller="CrossSellActivityController"
                access="global">

  <!-- Attributes -->
  <aura:attribute name="activities" type="Array" />
  <aura:attribute name="sortedBy" type="String" />
  <aura:attribute name="defaultSortDirection" type="String" default="asc" />
  <aura:attribute name="sortedDirection" type="String" default="asc" />
  <aura:attribute name="columns" type="List" />

  <!-- Component DOM -->
  <div>
    <lightning:datatable keyField="id"
                         data="{!v.activities}"
                         columns="{!v.columns}"
                         sortedBy="{!v.sortedBy}"
                         defaultSortDirection="{!v.defaultSortDirection}"
                         sortedDirection="{!v.sortedDirection}"
                         onsort="{!c.updateColumnSorting}"
                         hideCheckboxColumn="true" />
  </div>

</aura:component>

// definition unchanged
var columns = [
  { label: 'Program Key', fieldName: 'Program_Key__c', type: 'text', sortable: true },
  { label: 'Status', fieldName: 'Disposition__c', type: 'text', sortable: true },
  { label: 'User', fieldName: 'Username', type: 'text', sortable: true },
  { label: 'Asset', fieldName: 'Asset', type: 'text', sortable: true },
  { 
    label: 'Timestamp', 
    fieldName: 'CreatedDate', 
    type: 'date', 
    typeAttributes: {
      day: 'numeric',
      month: 'short',
      year: 'numeric',
      hour: '2-digit',
      minute: '2-digit',
      second: '2-digit',
      hour12: true
    },
    sortable: true
  }
];
component.set("v.columns", columns);

updateColumnSorting : function(component, event, helper) {
  var sortDirection = event.getParam('sortDirection');
  var sortedBy = event.getParam('fieldName');

  // log the sort direction to prove I'm right :P
  console.log('sortDirection: ', sortDirection);

  // sort using some helper method (the original OP didn't include their sort method so here's one that'll work)
  var data = component.get('v.activities'); // I'm assuming this is where the OP stored their data.
  data.sort( helper.compare(sortedBy, (sortDirection === 'asc' ? 1 : -1) ));

  // set the sortedBy and sortedDirection attributes to allow the table to keep track (note the spelling difference between sortDirection and sortedDirection).
  component.set("v.sortedBy", sortedBy);
  component.set("v.sortedDirection", sortDirection);
},

sortBy: function(field, reverse, primer) {
        // see https://developer.salesforce.com/docs/component-library/bundle/lightning:datatable/example#lightningcomponentdemo:exampleDatatableSorting
        
        // this just gets the value from appropriate column. x represents the row of the table and field represents the fieldName or the column you're sorting by
        var key = primer
            ? function(x) {
                  return primer(x[field]);
              }
            : function(x) {
                  return x[field];
              };

        // this figures out which order the two rows should go in when compared. It will return either -1, 0, or 1 and reorder the rows accordingly.
        return function(a, b) {
            a = key(a);
            b = key(b);
            return reverse * ((a > b) - (b > a));
        };
    }