A method for automatic program monitoring and number complement

Abstract

The present invention discloses a method for automatic program monitoring and complement, which defines input variables and initializes the variables; determines whether a time file of a root path exists, and if so, reads the file as the start time; if not, creates a new time file and saves the input start time; obtains the current running account period, and monitors whether it is executed to the end time according to ascending or descending calculation; sends a program start SMS and enters a batch loop, obtains the final account period after the running interval, monitors and compares the final account period and the end time of each batch, and determines whether the script batch data needs to be terminated after the execution ends; runs a data development script, and if the operation is successful, calculates the next execution account period and inputs it to the root path time file, thereby saving the start execution account period in the batch, when the program in the batch terminates unexpectedly, the root path time file can be read to obtain the breakpoint account period and continue to run, thereby achieving the effect of intelligent complement at the breakpoint; if the number of consecutive failures exceeds the limit, an alarm SMS is sent and the script ends; the actual end time is calculated according to ascending or descending order, and an end SMS is sent. In the process of data development, the present invention runs multiple account period data in batches and supports automatic complement and SMS alarm reminder at breakpoints.

Description

Technical Field

[0001] The invention belongs to the technical field of data monitoring, and in particular relates to a method for automatic program monitoring and number complementation. Background Art

[0002] When running large amounts of data, and data from different billing periods is dependent on each other and cannot be run simultaneously across multiple billing periods, if the program suddenly stops, you need to manually find the stop date and determine the next supplementary date based on the order of the running dates. This supplementary method is time-consuming and labor-intensive, especially when the program stops multiple times in the middle of a large number of billing periods. For example, when supplementing data from January to March, the data from January 5th to 10th, February 15th to 20th, and March 22nd to 26th all stop running unexpectedly. This requires manual searching for the stop date and reconfiguring the running date three times, which can easily affect the progress of back-end development and the stability of the back-end program.

[0003] Existing monitoring and data complementation technologies primarily query results by configuring monitoring table parameters, performing quality statistics on target tasks, and generating notification and alarm information corresponding to the preset monitoring tables. Alternatively, they obtain unprocessed source data from multiple data sources, preprocess it, and subsequently obtain the source data and corresponding standard tables. Job cycles and scheduling parameters are configured, and multiple data models are created based on the standard tables, each corresponding to a job with a specific job type and dependencies.

[0004] Some research focuses on monitoring log files, detecting new transaction records, reading the SQL instructions included in each transaction record from cache files, and synchronizing the read SQL instructions to the target end. A small amount of research focuses on incremental monitoring based on the data center. Some research focuses on shell scripts, recommending command methods for shell development tools, or extracting table names. Improved table extraction methods can reduce the tedious manual search for relevant tables for each script. Summary of the Invention

[0005] The technical problem to be solved by the present invention is to address the deficiencies of the above-mentioned existing technologies and provide a method for automatic program monitoring and number supplementation. During the data development process, multi-account period data is run in batches, and automatic number supplementation and SMS alarm reminders are supported at breakpoints.

[0006] In order to achieve the above technical objectives, the technical solution adopted by the present invention is:

[0007] A method for automatically monitoring and complementing numbers through a program, comprising the following steps:

[0008] Define input variables and initialize them. The input variables include start time, end time, time file, ascending or descending order, interval time for each batch, and number of failed retries.

[0009] Determine whether the root path's time file exists. If so, read the root path's time file as the start time. If not, create a new time file and save the entered start time. In subsequent steps, the root path's time file will automatically update to the start billing period of each batch. This ensures that when the program gets stuck and a breakpoint occurs, the execution billing period of the breakpoint is automatically saved and read, and the number is supplemented based on the breakpoint billing period.

[0010] Get the current running account period through the time file, and determine whether the current execution has reached the end time based on the ascending or descending order of the running account period. If so, end the program; otherwise, execute the next step to monitor the account period outside the while batch loop;

[0011] The program starts sending SMS messages and enters the batch loop. The current running time file bill period is added to the interval time of each batch to obtain the final bill period after the running interval. The final bill period of each batch is compared with the end time according to the ascending or descending order of the running bill period, thereby monitoring the bill period and determining whether the script batch data needs to be terminated after execution.

[0012] Run the data development script to determine whether the script has run successfully. If the current batch runs successfully, the start billing period of the next batch will be calculated based on the ascending or descending order of the running billing period, and the start billing period of the next batch will be entered into the root path time file. If a breakpoint occurs within the batch, the start billing period of the batch has been updated to the root path time file before the end of the previous batch, and the breakpoint has been recorded. The program can read the root path time file and obtain the breakpoint by itself, and automatically fill in the number from the breakpoint. If the run fails and the number of consecutive failures reaches the failure retry limit, an alarm SMS will be sent and the script will end.

[0013] Calculate the actual end time based on the ascending or descending order of the running account period and send an end SMS.

[0014] To optimize the above technical solutions, specific measures taken also include:

[0015] The aforementioned time file is used to store upcoming billing periods, facilitating file reading and comparison. The start billing period for each batch is automatically updated to the root path time file, allowing the program to automatically retrieve the breakpoint billing period from the time file and make up the difference when the program is restarted. When the program billing period is measured in days, the time file stores the date. If the program billing period is measured in months, the time file stores the month. Similarly, the time file is not limited to days and can also store time units such as minutes, hours, months, quarters, and years. The units for the subsequent start and end times are also set independently based on the program time unit and are not limited to daily granularity.

[0016] The ascending or descending order is the execution order of the running account period.

[0017] The interval time for each batch is the interval number of each batch of operating account periods, which is the number of each batch of operating account periods minus 1.

[0018] The above initialization variables include initialization input variables and initialization script root path, script file name, SMS jar package location, and SMS recipient.

[0019] The above procedure determines whether the current execution has reached the end time based on the ascending or descending order of the running account period. If so, the program ends. Otherwise, the next step is executed to monitor the account period outside the while batch loop, including:

[0020] When the execution order of the running bill period is descending, if the current running bill period is less than the end time, it means that the current running bill period has exceeded the end time, that is, the execution has reached the end time, and the program needs to be terminated;

[0021] When the execution order of the running account period is in ascending order, if the current running account period is greater than the end time, it means that the current running account period has exceeded the end time, that is, the execution has reached the end time, and the program needs to be terminated.

[0022] By comparing the bill period and end time of the root path time file, the execution bill period can be monitored to ensure that the current execution bill period will not automatically exceed the end time, and the start SMS will be sent only when the current running bill period is before the end time.

[0023] The above compares the final billing period and end time of each batch based on the ascending or descending order of the running billing period, thereby monitoring the billing period and determining whether the script batch data needs to be ended after execution, including:

[0024] If the execution order of the running account period is descending, then the program terminates after the corresponding batch data is executed if the final account period is less than or equal to the end time.

[0025] If the execution order of the running account period is in ascending order, then the program will terminate after the corresponding batch data execution is completed if the final account period is greater than the end time;

[0026] By comparing the final billing period and the end time of the batch, the execution billing period can be monitored to ensure that the current execution billing period will not automatically exceed the end time.

[0027] The above method calculates the next batch of billing period starting execution based on the ascending or descending order of the running billing period, and enters the next batch of billing period starting execution into the root path time file, including:

[0028] When the execution order of the running bill period is descending, the final bill period of each batch minus 1 is the next starting bill period;

[0029] When the execution order of the running bill period is in ascending order, the final bill period of each batch plus 1 is the next starting bill period;

[0030] Before the end of this batch, the calculated start period for the next batch is entered into the root path time file. If a breakpoint occurs within the batch, the start period of the batch has been updated to the root path time file before the end of the previous batch, and the breakpoint has been recorded. The program can read the root path time file and obtain the breakpoint by itself, and automatically fill in the number from the breakpoint.

[0031] The above consecutive failure count is initially assigned to 0. When the program fails to execute, the consecutive failure count increases by 1 each time it fails. If the execution is successful, the consecutive failure count is refreshed to 0 and the consecutive failure count is accumulated again.

[0032] The above calculation of the actual end time based on the ascending or descending order of the running account period includes:

[0033] When the execution order of the running bill period is descending, the final bill period of each batch minus 1 is the actual end time;

[0034] When the execution order of the running bill period is in ascending order, the actual end time is the final bill period of each batch plus 1.

[0035] The present invention has the following beneficial effects:

[0036] The variable parameters configured in the present invention include not only conventional start time, end time, etc., but also parameters such as time file, ascending or descending order, and interval time of each batch, which are convenient for multi-batch operation.

[0037] This invention monitors data not based on log files but by comparing the final billing period and end time of each batch in ascending or descending order of the executed billing periods. While monitoring, if the program unexpectedly stops, the invention can automatically identify the stopped billing period and intelligently fill in the gap at the breakpoint. If the program unexpectedly stops due to machine damage or network failure, the next time the program restarts, it can directly read the running billing period stored in the time file, automatically filling in the gap at the last breakpoint.

[0038] This invention automatically sets the interval between billing periods for each batch, i.e., the step size for each batch, thereby speeding up the script. When the data to be run includes a large number of billing periods, running only one billing period per batch will slow the script execution. However, supporting multiple billing periods per batch significantly improves the script's efficiency.

[0039] This invention allows for automatic configuration of ascending and descending order of bill periods, thereby automatically determining the order of the next bill period to be executed, and supports complementing bill periods in ascending or descending order. If the script only supports ascending order of bill periods, when descending order is required, a separate descending script must be written, increasing code redundancy. By supporting both ascending and descending order of bill periods, not only can the next bill period be automatically determined, but manual input of bill periods is also eliminated.

[0040] This method determines whether the program needs to be terminated by comparing the final billing period and end time of each batch in ascending or descending order. Because the script runs in batches, before each batch of data begins running, it first compares whether the final billing period of each batch exceeds the end time. If it does not exceed the end time, the batch of data will be run; if it does, the program will be terminated. Because the order of billing periods is not necessarily ascending or descending, the final billing period and end time will be compared in ascending or descending order, respectively.

[0041] The present invention sets up a separate time file and directly stores the account period to be executed into the time file. Since scripts often involve time calculation and comparison, such as calculating the next execution account period, or comparing the final account period and end time of each batch, this method will set up a separate dedicated time file to store the account period to be run, which is convenient for program reading. When the program account period is in days, the time file stores the date. If the program account period is in months, then the time file stores the month. Similarly, the content stored in the time file is not limited to days, and can also store time units such as minutes, hours, months, quarters, and years. The units of the subsequent start time and end time are also set independently according to the program time unit and are not limited to daily granularity. BRIEF DESCRIPTION OF THE DRAWINGS

[0042] Figure 1 The present invention is a flowchart of a method for automatic program monitoring and number complement. DETAILED DESCRIPTION

[0043] In order to make the purpose, technical solutions and advantages of the present invention more clearly understood, the present invention will be further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present invention and are not intended to limit the present invention.

[0044] Although the steps in the present invention are arranged with numbers, they are not intended to limit the order of the steps. Unless the order of the steps is clearly stated or the execution of a step requires other steps as a basis, the relative order of the steps can be adjusted. It is understood that the term "and / or" used herein refers to and covers any and all possible combinations of one or more of the associated listed items.

[0045] like Figure 1 As shown, a method for automatic program monitoring and complementing of the present invention comprises the following steps:

[0046] S1. Define input variables and initialize them, including "start time", "end time", "time file", "ascending or descending order", "interval between each batch", "number of failed retries", etc.

[0047] S2. Determine whether the root path time file exists. If it does, read the file as the start time. If it does not, create a new file and save the entered start time. In subsequent steps, the root path time file will automatically update to the start period of each batch. This ensures that if the program gets stuck and a breakpoint occurs, the execution period of the breakpoint is automatically saved and read, and the number is supplemented based on the breakpoint period.

[0048] S3. Obtain the current running account period through the time file, and determine whether to execute to the end time based on ascending or descending order, so as to monitor the account period outside the while batch loop.

[0049] S4. Send the program to start the SMS and enter the batch loop. Use the current running time file account period plus the interval time of each batch to obtain the final account period after the running interval. Compare the final account period and end time of each batch in ascending or descending order. Limit the final account period range so that it does not exceed the input end time, thereby monitoring the account period and determining whether the script needs to end after the batch data execution is completed.

[0050] S5. Run the data development script to determine if it has run successfully. If so, calculate the next batch's start date based on ascending or descending order and enter it into the root path time file. If a breakpoint occurs within a batch, the start date for that batch will have been updated to the root path time file before the previous batch ended, recording the breakpoint. The program can automatically read the root path time file to identify the breakpoint and automatically fill in the gaps.

[0051] When the number of consecutive failures reaches the limit, an alarm SMS is sent and the script ends.

[0052] S7. Calculate the actual end time based on the ascending or descending order of the execution account period and send an end SMS.

[0053] In the embodiment, S1 defines input variables and initializes variables, mainly including "start time", "end time", "time file", "ascending or descending order", "interval time for each batch", "number of failed retries", etc.

[0054] Define the input variables required for script execution, including start time, end time, time file, ascending or descending order, interval time for each batch, number of retries upon failure, and end time of script execution for the day.

[0055] The "time file" variable is used to store the upcoming billing period, such as 20240101. This makes it easier to read and compare the start billing period of the file. The start billing period of each batch is automatically updated to the root path time file, which helps automatically obtain the breakpoint billing period from the time file and make up the number when the program restarts.

[0056] The "Ascending or Descending" variable represents the order in which the account periods are executed. For example, if the order is 20240101, 20240102, and 20240103, it indicates ascending order. If the order is 20240131, 20240130, and 20240129, it indicates descending order.

[0057] The "Batch Interval" represents the number of billing periods between each batch, which is the number of billing periods per batch minus 1. For example, if you want to run data for 10 days from January 1, 2024, to January 10, 2024, and each batch runs for 2 days, with the first batch covering days 1-2 and the second batch covering days 3-4, then the "Batch Interval" is 1. If each batch runs for 5 days, with the first batch covering days 1-5 and the second batch covering days 6-10, then the "Batch Interval" is 4.

[0058] If a task fails for a specified number of times in a row, the script stops running and a text message is sent to notify the user.

[0059] In addition to the above input variables, the initialization variables also include the initialization script root path (path), script file name (file_name), SMS jar package location (send_msg_jar_path), and SMS recipient (link_man).

[0060] In this embodiment, S2 determines whether a root path time file exists. If so, it reads the file as the start time. If not, a new file is created and the entered start time is saved. In subsequent steps, the root path time file is automatically updated to the start account period of each batch. This ensures that when the program is stuck and a breakpoint occurs, the execution account period of the breakpoint is automatically saved and read, and the number is supplemented based on the breakpoint account period.

[0061] Check whether the time file in the root path exists. If so, read the data from the time file in the root path as the start time. If the file does not exist in the root path, create a new file to save the input start time.

[0062] The sample code is as follows:

[0063]

[0064] In the embodiment, S3 obtains the current running account period through the time file, and determines whether to execute to the end time according to ascending or descending order, so as to monitor the account period outside the while batch loop.

[0065] Get the current billing period based on the time file in the root path. Get the execution order of the billing periods based on the "ascending or descending" variable.

[0066] When the running order is descending, if the current running bill period is less than the end time, it means that the current running bill period has exceeded the end time and the program needs to be terminated; when the running order is ascending, if the current running bill period is greater than the end time, it means that the current running bill period has exceeded the end time and the program also needs to be terminated.

[0067] By comparing the bill period and end time of the root path time file, the execution bill period can be monitored to ensure that the current execution bill period will not automatically exceed the end time. It also ensures that the start SMS is sent only when the current running bill period is before the end time.

[0068] The bill period comparison in this step is outside the while batch loop. If the end time is exceeded, the start SMS of the next step will not be sent.

[0069] The sample code is as follows:

[0070]

[0071] In the embodiment, S4 sends a program start SMS and enters a batch loop, uses the current running time file bill period plus the interval time of each batch to obtain the final bill period after the running interval, compares the final bill period and the end time of each batch in ascending or descending order, limits the final bill period range so that it does not exceed the input end time, thereby monitoring the bill period and determining whether the script needs to end after the execution of the batch data is completed.

[0072] Since the interval time of each batch is not fixed, it is necessary to add the current running file billing period to the interval time of each batch to know the last billing period of the current batch.

[0073] If the execution order is descending, the program will terminate after the batch of data is executed if the final payment period is less than or equal to the end time. If the execution order is ascending, the program will terminate after the batch of data is executed if the final payment period is greater than the end time.

[0074] By comparing the final billing period and the end time of the batch, the execution billing period can be monitored to ensure that the current execution billing period will not automatically exceed the end time.

[0075] The sample code is as follows:

[0076]

[0077] In this embodiment, S5 runs the data development script and determines whether the script has run successfully. If so, it calculates the start date of the next batch based on ascending or descending order and enters this date into the root path time file. If a breakpoint occurs within a batch, the start date of that batch will have been updated to the root path time file before the previous batch ends, recording the breakpoint. The program can automatically read the root path time file to obtain the breakpoint and automatically fill in the gaps.

[0078] Enter the starting and ending billing periods for the batch and run the data development script.

[0079] #Run data development script

[0080] sh${path} / ${file_name}.sh${day_id1}${day_id2}

[0081] The time file contains only one billing period, representing the billing period to be executed. After the batch is successfully executed, the next billing period is automatically calculated based on the ascending or descending order and stored in the time file. When the billing period is in descending order, the next billing period is calculated by decrementing the final billing period of each batch; when the billing period is in ascending order, the next billing period is calculated by incrementing the final billing period of each batch.

[0082] For example, if the current time file content is 20240101, the interval time for each batch is 1, and the execution account period is in ascending order, the batch runs the data of 20240101 and 20240102. When the batch runs successfully, the next execution account period is automatically calculated as 20240103, and the content of the time file is automatically updated to 20240103.

[0083] The program will transfer the start period of each batch to the root path time file. If a batch of programs is interrupted or stuck, causing the program to end and a breakpoint to occur, the root path time file will have already recorded the start period of the next batch before the previous batch ended, thus recording the program breakpoint. We can simply print the root path time file to know the program breakpoint period. The program's start node is obtained by reading the root path time file. Therefore, when the program breaks, the program automatically records the breakpoint period, updates the root path time file, obtains the complement start time, and runs again from the breakpoint.

[0084] The sample code is as follows:

[0085]

[0086] In the embodiment, when the number of consecutive failures reaches a limit, an alarm text message is sent and the program ends.

[0087] The number of consecutive failures is initially assigned to 0. When the program fails, the failure count increases by 1 each time it fails. If the program succeeds, the failure count is reset to 0 and the failure count is accumulated again. If the number of failures reaches the limit, an alarm SMS is sent and the program ends.

[0088] In the embodiment, S6 calculates the actual end time according to the ascending or descending order of the execution account period and sends an end SMS.

[0089] When the payment period is in descending order, the actual end time is calculated by deducting 1 from the final payment period of each batch. When the payment period is in ascending order, the actual end time is calculated by adding 1 to the final payment period of each batch. The actual end time is printed at the end.

[0090] The sample code is as follows:

[0091]

[0092] Specific embodiments are as follows:

[0093]

[0094]

[0095]

[0096]

[0097]

[0098]

[0099]

[0100]

[0101] The definitions of the terms in the above text are as follows:

[0102] Root path: usually refers to the top level or root directory of a file system, indicating the starting point of all files and directories in the computer system.

[0103] Account period: The account period in this method refers to the time account period required for the script to run, such as 20240101, 20240102.

[0104] Batch loop: The batch loop in this method refers to a while loop, and the data is run in batches when the monitoring conditions are met. It is obvious to those skilled in the art that the present invention is not limited to the details of the above-mentioned exemplary embodiments, and the present invention can be implemented in other specific forms without departing from the spirit or basic characteristics of the present invention. Therefore, from any point of view, the embodiments should be regarded as exemplary and non-restrictive, and the scope of the present invention is defined by the appended claims rather than the above description. Therefore, it is intended that all changes that fall within the meaning and scope of the equivalent elements of the claims are included in the present invention. Any figure mark in the claims should not be regarded as limiting the claim involved.

[0105] In addition, it should be understood that although this specification is described in terms of implementation methods, not every implementation method contains only one independent technical solution. This narrative method of the specification is only for the sake of clarity. Those skilled in the art should regard the specification as a whole. The technical solutions in each embodiment can also be appropriately combined to form other implementation methods that can be understood by those skilled in the art.

Claims

1. A method for automatic program monitoring and complementing, characterized in that: The following steps are involved: Define input variables and initialize them. The input variables include start time, end time, time file, ascending or descending order, interval time for each batch, and number of failed retries. Determine whether the root path time file exists. If so, read the root path time file as the start time. If not, create a new time file and save the entered start time. The root path time file is automatically updated to the start account period of each batch. This ensures that when the program is stuck and a breakpoint occurs, the execution account period of the breakpoint is automatically saved and read, and the number is supplemented based on the breakpoint account period. Get the current running account period through the time file, and determine whether the current execution has reached the end time based on the ascending or descending order of the running account period. If so, end the program; otherwise, execute the next step to monitor the account period outside the while batch loop; The program starts sending SMS messages and enters the batch loop. The billing period of the current running time file is added to the interval time of each batch to obtain the final billing period after the running interval. The final billing period of each batch is compared with the end time according to the ascending or descending order of the running billing period, thereby monitoring the billing period and determining whether the script batch data needs to be terminated after execution is completed. Run the data development script to determine whether the script has run successfully. If the current batch runs successfully, the start billing period of the next batch will be calculated based on the ascending or descending order of the running billing period, and the start billing period of the next batch will be entered into the root path time file. If a breakpoint occurs within the batch, the start billing period of the batch has been updated to the root path time file before the end of the previous batch, and the breakpoint has been recorded. The program can read the root path time file and obtain the breakpoint by itself, and automatically fill in the number from the breakpoint. If the run fails and the number of consecutive failures reaches the failure retry limit, an alarm SMS will be sent and the script will end. The actual end time is calculated based on the ascending or descending order of the running account period, and an end SMS is sent.

2. A method for automatic program monitoring and complementing according to claim 1, characterized in that: The time file is used to store the billing period to be executed, so as to facilitate reading and comparing the file time. The starting billing period of each batch is automatically updated to the root path time file, so that when the program is restarted, the breakpoint billing period is automatically obtained from the time file and the number is supplemented. The time file is stored according to the time granularity of the program billing period, and the time granularity includes time units such as minute, hour, day, month, quarter, and year. The ascending or descending order is the execution order of the running account period; The interval time for each batch is the interval number of each batch of operating account periods, which is the number of each batch of operating account periods minus 1.

3. A method for automatic program monitoring and complementing according to claim 1, characterized in that: The initialization variables include initialization input variables and initialization script root path, script file name, SMS jar package location, and SMS recipient.

4. A method for automatic program monitoring and complementing according to claim 1, characterized in that: According to the ascending or descending order of the running account period, it is judged whether the current execution has reached the end time. If so, the program ends, otherwise the next step is executed to monitor the account period outside the while batch loop, including: When the execution order of the running bill period is descending, if the current running bill period is less than the end time, it means that the current running bill period has exceeded the end time, that is, the execution has reached the end time, and the program needs to be terminated; When the execution order of the running bill period is in ascending order, if the current running bill period is greater than the end time, it means that the current running bill period has exceeded the end time, that is, the execution has reached the end time, and the program needs to be terminated; By comparing the bill period and end time of the root path time file, the execution bill period can be monitored to ensure that the current execution bill period will not automatically exceed the end time, and the start SMS will be sent only when the current running bill period is before the end time.

5. The method of automatic program monitoring and number complement according to claim 1, characterized in that: The final bill period and end time of each batch are compared according to the ascending or descending order of the running bill period, so as to monitor the bill period and determine whether the script batch data needs to be ended after execution, including: If the execution order of the running account period is descending, then the program will terminate after the corresponding batch data execution is completed if the final account period is less than or equal to the end time; If the execution order of the running account period is in ascending order, then the program will terminate after the corresponding batch data execution is completed if the final account period is greater than the end time; By comparing the final billing period and the end time of the batch, the execution billing period can be monitored to ensure that the current execution billing period will not automatically exceed the end time.

6. A method for automatic program monitoring and number complement according to claim 1, characterized in that: The calculation of the next batch of billing period starts according to the ascending or descending order of the running billing period, and inputting the next batch of billing period starts into the root path time file includes: When the execution order of the running bill period is descending, the final bill period of each batch minus 1 is the next starting bill period; When the execution order of the running bill period is in ascending order, the final bill period of each batch plus 1 is the next starting bill period; Before the end of this batch, the calculated start period for the next batch is entered into the root path time file. If a breakpoint occurs within the batch, the start period of the batch has been updated to the root path time file before the end of the previous batch, and the breakpoint has been recorded. The program can read the root path time file and obtain the breakpoint by itself, and automatically fill in the number from the breakpoint.

7. A method for automatic program monitoring and number complement according to claim 1, characterized in that: The number of consecutive failures is initially assigned to 0. When the program fails to execute, the number of consecutive failures increases by 1 each time it fails. If the execution is successful, the number of consecutive failures is refreshed to 0 and the number of consecutive failures is accumulated again.

8. A method for automatic program monitoring and number complement according to claim 1, characterized in that: The actual end time is calculated based on the ascending or descending order of the running account period, including: When the execution order of the running bill period is descending, the final bill period of each batch minus 1 is the actual end time; When the execution order of the running bill period is in ascending order, the actual end time is the final bill period of each batch plus 1.

Images