Complicated DIFF method

This sort of data can be processed fairly easily as a multi-level associative array (or Hash-of-Hashes / HoH in perl terminology, see perldsc, the perl Data Structures Cookbook), with the first level key being the node name and the second-level keys (which I'm calling the "sub-key" in the script below) being the relevant field names (Availability, State, Reason, etc).

For example:

#!/usr/bin/perl

use strict;

die "Usage $0 [oldfile] [newfile]\n" unless (@ARGV == 2) ;

# remember both filename args
my ($oldfile,$newfile) = @ARGV[0,1];

die "$oldfile is not readable or does not exist\n" unless -r $oldfile;
die "$newfile is not readable or does not exist\n" unless -r $newfile;

# Hash variables to hold old and new data
my (%old, %new);

# Hash reference variable pointing to the hash we want
# the main loop to populate at any given moment.
# Starts off pointing to %old, changes to %new after the
# first file reaches end-of-file.
# See https://perldoc.perl.org/perlreftut and
# https://perldoc.perl.org/perlref
my $hashref = \%old;

# variable to hold the name of the current node name as
# the records in the input files are read in.
my $node;

# read and parse input files
while(<>) {
  chomp;
  s/^\s*|\s*$//g; # strip leading and trailing whitespace
  s/\s+:\s+/ : /; # strip excess whitespace around first :

  if (/^Ltm::Node:.*\s+\((.*)\)/) {
    $node = $1;
    $hashref->{$node}{name} = $node;
  } elsif (/ : /) {
    my ($key, $val) = split / : /,$_, 2;
    $hashref->{$node}{$key} = $val
  } else {
    print STDERR "Unknown data '$_' on line $. of $ARGV\n";
  };

  if (eof) {
    close(ARGV);       # reset line counter
    $hashref = \%new;  # start populating %new instead of %old
  }
};

# compare the keys from both files
my @common_keys = ();
foreach my $k (keys %old) {
  if (exists($new{$k})) {
    push @common_keys, $k;
  } else {
    print "Node $k found in $oldfile but not in $newfile\n"
  };
};

foreach my $k (keys %new) {
  if (! exists($old{$k})) {
    print "Node $k found in $newfile but not in $oldfile\n";
  };
}

# The list of sub-keys we care about.
my @subkeys = ('Availability', 'State', 'Reason', 'Monitor',
               'Monitor Status');

# now compare sub-keys in each of the nodes
foreach my $k (@common_keys) {
  foreach my $sk (@subkeys) {
    if ($old{$k}{$sk} ne $new{$k}{$sk}) {
      printf "[%-15s %-14s] Old = \"%s\", new = \"%s\"\n", $k, $sk,
        $old{$k}{$sk}, $new{$k}{$sk};
    }
  }
}

Save this as, e.g. compare.pl, make it executable with chmod +x compare.pl and run it like this:

$ ./compare.pl old.txt new.txt  
Node 10.72.12.150 found in old.txt but not in new.txt
Node 10.72.12.149 found in new.txt but not in old.txt
[10.72.12.148    State         ] Old = "enabled", new = "xenabled"
[10.72.7.122     Reason        ] Old = "Node address does not have service checking enabled", new = "xNode address does not have service checking enabled"

Note: Apart from minor differences on the Ltm::Node lines, the data in both of your input files was identical, so I had to make some differences by editing new.txt to add an x before some fields. I also added node 10.172.12.150 to old.txt and 10.172.12.149 to new.txt.

Also worth noting, perl hashes are inherently unordered so the output may print the node differences in a different order on each run. It would be easy enough to get a consistent order by sorting %old while populating the @common_keys array, but you'd have to implement a natural-sort/version-sort subroutine (or use one of the natural sort modules on CPAN) for the IP addresses to sort correctly. I'll leave that enhancement as an exercise for the reader - it's not necessary for this example.

You can edit the print statements to change the output to suit your needs. You didn't specify the output, so I just printed what seemed necessary to easily identify the differences.

It wouldn't be difficult to write something similar in awk (especially GNU awk, as it has reasonable support for multi-dimensional arrays) but I prefer perl even if it tends to be a bit more verbose than awk (actually partly because of that).