My solution would be almost identical to @Jon's, but I'd start the timer in one-shot mode, to avoid getting a second interrupt when processing the first takes too long. This way, no timer stop function is needed.

void TIM1_Init() {
    // edit: added clock and interrupt enable
    __HAL_RCC_TIM1_CLK_ENABLE();
    NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 0);
    NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);

    TIM1->PSC = 16799;         // prescaler
    TIM1->EGR = TIM_EGR_UG;    // generate an update event to load the prescaler
    TIM1->ARR = 4999;          // counter limit
    TIM1->SR = 0;              // clear interrupt status after the update event
    TIM1->DIER = TIM_DIER_UIE; // enable interrupt on update (overflow) event
}

void TIM1_Stop() {
    TIM1->CR1 = 0;             // stop timer by clearing CEN (and everything else) in CR1
    TIM1->CNT = 0;             // reset counter, so it will start from 0 at restart
}

void TIM1_Start() {
    TIM1->CR1 = TIM_CR1_CEN    // start the timer
        | TIM_CR1_OPM;         // in one-pulse-mode
}

void TIM1_UP_TIM10_IRQHandler(void) {
    TIM1->SR = 0;
    strcpy(str123,"<<FAIL>>"); // sprintf should not be used in an interrupt handler
    CDC_Transmit_FS((uint8_t*)str123,strlen(str123));
}

You haven't shown us all the code. For example, where is the Timer and GPIO peripherals enabled? And where is the Timer interrupt enabled?

Typically with STM32Cube HAL applications, the functions like HAL_TIM_Base_Init() call another function like HAL_TIM_Base_MspInit(), which you may have to provide an implementation for. The xxx_MspInit() functions are typically implemented in a file called stm32xxxx_hal_msp.c. ST provides a template for this file with the HAL but I believe the expectation is that you will copy the template to your project file and customize it. (I'm not familiar with the STM32CubeMX tool, which might do some of this automatically.)

Typically within HAL_TIM_Base_MspInit() in stm32xxxx_hal_msp.c is where you will enable the timer and the timer interrupt. That code will look something like this:

    // Enable the peripheral clock.
    __HAL_RCC_TIM10_CLK_ENABLE();

    // NVIC configuration for the TIM10 interrupt.
    HAL_NVIC_SetPriority(TIM10_IRQn, 3, 0);
    HAL_NVIC_EnableIRQ(TIM10_IRQn);

Then you also need to provide an implementation for the timer interrupt handler. Typically this is done in a file called stm32xxxx_it.c. This is another file provided as a template with the HAL but you're expected to customize it in your project directory. (And again, STM32CubeMX may do some of this automatically.)

/**
* @brief  This function handles TIM10_IRQHandler interrupt request.
* @param  None
* @retval None
*/
void TIM10_IRQHandler(void)
{
    HAL_TIM_IRQHandler(&htim10);
}

It's HAL_TIM_IRQHandler() which then calls your HAL_TIM_PeriodElapsedCallback() function.

So make sure you've enabled the timer and the timer interrupt in HAL_TIM_Base_MspInit(). Then make sure you've provided an implementation for TIM10_IRQHandler() which calls HAL_TIM_IRQHandler(). Then use the debugger to step through the code. Set breakpoints in HAL_TIM_Base_MspInit() and TIM10_IRQHandler() and HAL_TIM_PeriodElapsedCallback() to figure out what is working and what is not working.

It sounds like the SysTick is ideal for your purposes.

SysTick is a timer which is loaded with a customizable value. Every instruction, it gets decremented by one. When the value reaches 0, it gets reset to it's load value and started again. Also, a status flag is set. You can poll this status flag in software.