Read through a log file to find serial numbers based upon prior information found
This looks like a very complex class to me. All you really want to do is read all lines of an error log and keep a dictionary mapping hardware busses to drives, where each drive has a name (like sda), a bus and a serial. If you encounter an xfs error for one of these drives, return its serial number.

This can be accomplished by defining a basically empty Drive class and filling it successively. You don't even need the SerialNumberFinder class, one function is enough:

import collections


class Drive:
    """Object to hold all information about a drive."""
    pass


def get_serial_numbers(file_name):
    """Return a list of serial numbers of drives with XFS errors"""
    drives = collections.defaultdict(Drive)
    try:
        with open(file_name) as f:
            for line in f:
                bus = re.match(r"(sd \S+) (\[sd[a-z]\]).*", line)
                if bus:
                    bus_name, device_name = bus.groups()
                    drives[bus_name].name = device_name
                    continue

                serial = re.match(r"(sd \S+) \(SERIAL=([^)]*)\)", line)
                if serial:
                    bus_name, serial = serial.groups()
                    drives[bus_name].serial = serial
                    continue

                error_disk = re.match(r"XFS ERROR (\[sd[a-z]\])", line)
                if error_disk:
                    device_name, = error_disk.groups()
                    for drive in drives.values():
                        if drive.name == device_name:
                            yield drive.serial
    except FileNotFoundError:
        print("Cannot find file {}".format(file_name))
        raise

if __name__ == "__main__":
    nums = get_serial_numbers("EXAMPLE_LOG.log")
    print(list(nums))


Note that it is often recommended to compile your regexes, i.e do something like:

bus_re = re.compile(r"(sd \S+) (\[sd[a-z]\]).*")
...
bus = bus_re.match(line)


However, Python already does this for you in the background. So whenever a new regex is encountered, it is compiled and this compiled regex is used for all future appearances of this regex. The only time when you should do this is, if you have more than 100 regexes (the default cache size), if you want to take the performance hit of compiling it once way before you run the actual code or if you want to give a regex a nice understandable name.