Substring: What is causing my output to be truncated?

It is quite likely you're out of memory. To know, really you need to keep track of the stack pointer and heap structure. There's enough going on in your code, that I'm not reasonably going to be able to set up an identical scenario to prove it.

Display Library

The greatest use of SRAM in your project comes from the Adafruit SSD1306 library. It's allocating a buffer for the entire frame, which is 128 * 64 == 8192 bits, or 1024 bytes, half your Nano's SRAM. It will use more than that for other data, though probably not a lot more by percentage.

You may be able to mitigate this usage with a library like trades some SRAM usage for extra execution time or lower frame rates. One is the U8g2 library. You can read about how it can use half-buffer in some documentation to the older version of the library; the concept carries over to the newer library.

SD Library

The next largest usage is the SD card libraries sector buffer, which is 512 bytes.

So between the two of them, there go 3/4 of your SRAM in just the two buffers, nevermind anything else.

You may be able to avoid this buffer by using a different library. You could try PetitFS. The library it wraps says it uses something like 44 bytes plus whatever call stack is needed.

String Literals

You have at least 206 bytes of string literals in your sketch alone, assuming the compiler can't determine that any of them are in fact unused. There may be others in the libraries, though probably not many. So now we're down to at least 306 bytes or less SRAM.

The "0" is only counted once in the above, even though you have two of them. Fun fact: the C and C++ languages allow identical string literals to be colocated or overlap. I don't know whether or not avr-gcc will combine "Name: " into "bName: ", since you have bigger problems to worry about, I'm just pretending it won't without looking.

Mitigation can include use of the F() macro to move some of these string literals into PROGMEM (flash). You can't do this to every string literal, but the ones where you're involving them in a String(F("we're trying to avoid these right?")) constructor or in Serial (or other Stream/Print instances)'s .print(F("Hello World"));

The guts of the F() macro is another called PSTR(), which does the actual work of putting the string literal into PROGMEM. F() tags the resulting pointer with a dummy type that is used in function overloading in Arduino libraries. The only reason why I mention this is because below, you'll see me use PSTR to do the same thing, only with a function that belongs to avr-libc rather than Arduino.

Note when you're initializing a String object from a regular string literal, you're paying the SRAM cost twice for the lifetime of the String object. One copy is in SRAM for the literal used to call the String constructor, the other copy is in the dynamic memory allocated to the String object.

String class

This was pointed out in the comments; and it's true that it's better to avoid them. Although, I think not actually the greatest problem in your case.

I see you've avoided unnecessarily adding them together for Serial output and instead are using separate .print() calls, so you're ahead of the game there.

For your filename, mitigation could be using fixed size local char array and snprintf_P() to cobble together your filename, something like:

char filename[sizeof "MM-DD.txt"];
snprintf_P(
    filename, sizeof filename,
    PSTR("%02u-%02u.txt"),
    tMth, tDy
);

or if you wanted to avoid pulling the beast of printf into your sketch, assuming it's not already there, you could do something like:

const char filename[] = {
    '0' + tMth / 10,
    '0' + tMth % 10,
    '-',
    '0' + tDy  / 10,
    '0' + tDy  % 10,
    '.',
    't',
    'x',
    't',
    '\0'
};

Serial

What Serial? Yup, I mean, there's not a lot you can do about it, but I bring it up because the last conservative figure above was 306 bytes, and we didn't try to account for the what String is doing in the heap at all. Well Serial takes 157 bytes according to a simple test here, which makes sense, because on the UNO it has two ring buffers for transmit and receive that are 64 bytes in size each, half a dozen pointers for configuring hardware registers to use, and head and tail indices for those buffers. There's also another 12 bytes that are used for HardWareSerial's vtable.

So that puts you down to conservatively 137 bytes of SRAM for well, everything else.

Everything Else

There's a lot not accounted for here. Your globals, the libraries globals, other vtables, the String data on the heap, and the stack. Those are just the ones coming to mind. I mean just the millis()/micros() counter variables and fract take 9 bytes. If you really want to dig into the details here, besides looking at the stack pointer and heap structure, the avr-nm command run on your sketch's .elf file with its -D, -S, and --size-sort is helpful for locating global variable usage and similar things.