diff --git a/src/utils/rumUtil.erl b/src/utils/rumUtil.erl
index b318d6b..f331a26 100644
--- a/src/utils/rumUtil.erl
+++ b/src/utils/rumUtil.erl
@@ -271,8 +271,7 @@ calcNextRotate([], Data, Time, NowDataTime) ->
    Later = {Data, Time},
    calendar:datetime_to_gregorian_seconds(Later) - calendar:datetime_to_gregorian_seconds(NowDataTime);
 calcNextRotate([OneSpec | Spec], NDate, NTime, NowDataTime) ->
-   {NHour, NMinute, _} = NTime,
-   {NYear, NMonth, NDay} = NDate,
+   {NYear, NMonth, NDay} = NDate, {NHour, NMinute, _} = NTime,
    case OneSpec of
       {minute, SMinute} ->
          case NMinute < SMinute of
@@ -281,21 +280,21 @@ calcNextRotate([OneSpec | Spec], NDate, NTime, NowDataTime) ->
                calcNextRotate(Spec, NDate, {NHour, SMinute, 0}, NowDataTime);
             _ ->
                %% rotation is next hour
-               NexSec = rumTime:lDateTimeToSec(NowDataTime) + 3600,
+               NexSec = rumTime:lDateTimeToSec({NDate, NTime}) + 3600,
                {NNDate, NNTime} = rumTime:secToLDateTime(NexSec),
                {NewHour, _, _} = NNTime,
-               calcNextRotate(Spec, NNDate, {NewHour, SMinute, 0},  NowDataTime)
+               calcNextRotate(Spec, NNDate, {NewHour, SMinute, 0}, NowDataTime)
          end;
       {hour, SHour} ->
          case NHour < SHour of
             true ->
                %% rotation is today, sometime
-               calcNextRotate(Spec, NDate, {SHour, 0, 0}, NowDataTime);
+               calcNextRotate(Spec, NDate, {SHour, NMinute, 0}, NowDataTime);
             _ ->
                %% rotation is not today
-               NexSec = rumTime:lDateTimeToSec(NowDataTime) + 86400,
+               NexSec = rumTime:lDateTimeToSec({NDate, NTime}) + 86400,
                {NNDate, _NNTime} = rumTime:secToLDateTime(NexSec),
-               calcNextRotate(Spec, NNDate, {SHour, 0, 0}, NowDataTime)
+               calcNextRotate(Spec, NNDate, {SHour, NMinute, 0}, NowDataTime)
          end;
       {day, SDay} ->
          CurDay = rumTime:weekDay(NDate),
@@ -303,64 +302,63 @@ calcNextRotate([OneSpec | Spec], NDate, NTime, NowDataTime) ->
          if
             AdjustedDay > CurDay ->
                PlusDays = AdjustedDay - CurDay,
-               NexSec = rumTime:lDateTimeToSec(NowDataTime) + (86400 * PlusDays),
-               {NewDate, _} = rumTime:secToLDateTime(NexSec),
-               NewNow = {NewDate, {0, 0, 0}},
-               calcNextRotate(Spec, NewNow);
+               NexSec = rumTime:lDateTimeToSec({NDate, NTime}) + (86400 * PlusDays),
+               {NewNDate, NewNTime} = rumTime:secToLDateTime(NexSec),
+               calcNextRotate(Spec, NewNDate, NewNTime, NowDataTime);
             AdjustedDay < CurDay ->
                PlusDays = ((7 - CurDay) + AdjustedDay),
-               NexSec = rumTime:lDateTimeToSec(NowDataTime) + (86400 * PlusDays),
-               {NewDate, _} = rumTime:secToLDateTime(NexSec),
-               NewNow = {NewDate, {0, 0, 0}},
-               calcNextRotate(Spec, NewNow);
+               NexSec = rumTime:lDateTimeToSec({NDate, NTime}) + (86400 * PlusDays),
+               {NewNDate, NewNTime} = rumTime:secToLDateTime(NexSec),
+               calcNextRotate(Spec, NewNDate, NewNTime, NowDataTime);
             true ->
-               case calcNextRotate(Spec, Now) of
-                  {Date, _} = NewNow -> NewNow;
-                  {NewDate, _} ->
-                     %% rotation *isn't* today! rerun the calculation
-                     NewNow = {NewDate, {0, 0, 0}},
-                     calcNextRotate([{day, SDay} | Spec], NewNow)
+               case {NDate, NTime} > NowDataTime of
+                  true ->
+                     calcNextRotate(Spec, NDate, NTime, NowDataTime);
+                  _ ->
+                     NexSec = rumTime:lDateTimeToSec({NDate, NTime}) + (86400 * 7),
+                     {NewNDate, NewNTime} = rumTime:secToLDateTime(NexSec),
+                     calcNextRotate(Spec, NewNDate, NewNTime, NowDataTime)
                end
          end;
       {date, last} ->
-         Last = rumTime:monthDay(NYear, NMonth),
-         case Last == Day of
-            true -> %% doing rotation today
-               case calcNextRotate(T, Now) of
-                  {{Year, Month, Day}, _} = NewNow -> NewNow;
-                  {NewDate, _} ->
-                     %% rotation *isn't* today! rerun the calculation
-                     NewNow = {NewDate, {0, 0, 0}},
-                     calcNextRotate([{date, last} | T], NewNow)
+         LastDay = rumTime:monthDay(NYear, NMonth),
+         case LastDay == NDay of
+            true ->
+               case {NDate, NTime} > NowDataTime of
+                  true ->
+                     calcNextRotate(Spec, NDate, NTime, NowDataTime);
+                  _ ->
+                     NexSec = rumTime:lDateTimeToSec({NDate, {23, 59, 59}}) + 1,  %% 下个月1号凌晨
+                     {NewNDate, _NewNTime} = rumTime:secToLDateTime(NexSec),
+                     {NewNYear, NewNMonth, _} = NewNDate,
+                     NewNDay = rumTime:monthDay(NewNYear, NewNMonth),
+                     calcNextRotate(Spec, {NewNYear, NewNMonth, NewNDay}, NTime, NowDataTime)
                end;
-            false ->
-               NewNow = setelement(1, Now, {Year, Month, Last}),
-               calcNextRotate(T, NewNow)
+            _ ->
+               calcNextRotate(Spec, {NYear, NMonth, LastDay}, NTime, NowDataTime)
          end;
       {date, SDate} ->
          if
             SDate < NDay ->
-               Last = calendar:last_day_of_the_month(Year, Month),
-               (Last - Day),
-               Seconds = calendar:datetime_to_gregorian_seconds(Now) + (86400 * PlusDays),
-               NewNow = calendar:gregorian_seconds_to_datetime(Seconds),
-               calcNextRotate(T, NewNow);
+               LastDay = rumTime:monthDay(NYear, NMonth),
+               NexSec = calendar:lDateTimeToSec({{NYear, NMonth, LastDay}, {23, 59, 59}}) + 1,
+               {NewNDate, _NewNTime} = rumTime:secToLDateTime(NexSec),
+               {NewNYear, NewNMonth, _} = NewNDate,
+               calcNextRotate(Spec, {NewNYear, NewNMonth, SDate}, NTime, NowDataTime);
             SDate > NDay ->
-               X - Day,
-               Seconds = calendar:datetime_to_gregorian_seconds(Now) + (86400 * PlusDays),
-               NewNow = calendar:gregorian_seconds_to_datetime(Seconds),
-               calcNextRotate(T, NewNow);
+               calcNextRotate(Spec, {NYear, NMonth, SDate}, NTime, NowDataTime);
             true ->
-               %% rotation is today
-               case calcNextRotate(T, Now) of
-                  {{Year, Month, Date}, _} = NewNow -> NewNow;
-                  {NewDate, _} ->
-                     %% rotation *isn't* today! rerun the calculation
-                     NewNow = setelement(1, Now, NewDate),
-                     calcNextRotate([{date, Date} | T], NewNow)
+               case {NDate, NTime} > NowDataTime of
+                  true ->
+                     calcNextRotate(Spec, NDate, NTime, NowDataTime);
+                  _ ->
+                     LastDay = rumTime:monthDay(NYear, NMonth),
+                     NexSec = calendar:lDateTimeToSec({{NYear, NMonth, LastDay}, {23, 59, 59}}) + 1,
+                     {NewNDate, _NewNTime} = rumTime:secToLDateTime(NexSec),
+                     {NewNYear, NewNMonth, _} = NewNDate,
+                     calcNextRotate(Spec, {NewNYear, NewNMonth, SDate}, NTime, NowDataTime)
                end
          end
-
    end.
 
 -spec trace_filter(Query :: 'none' | [tuple()]) -> {ok, any()}.