feat(error): an idea for simple stack

Author: JiaLiPassion

lib/zone.ts

@@ -1664,11 +1664,13 @@ const Zone: ZoneType = (function(global: any) {
             case FrameType.transition:
               if (zoneFrame.parent) {
                 // This is the special frame where zone changed. Print and process it accordingly
-                frames[i] += ` [${zoneFrame.parent.zone.name} => ${zoneFrame.zone.name}]`;
+                // frames[i] += ` [${zoneFrame.parent.zone.name} => ${zoneFrame.zone.name}]`;
                 zoneFrame = zoneFrame.parent;
               } else {
                 zoneFrame = null;
               }
+              frames.splice(i, 1);
+              i--;
               break;
             default:
               frames[i] += ` [${zoneFrame.zone.name}]`;
@@ -1834,6 +1836,67 @@ const Zone: ZoneType = (function(global: any) {
   // carefully constructor a stack frame which contains all of the frames of interest which
   // need to be detected and blacklisted.
 
+  const parentDetectSpec = {name: 'parent'};
+  const childDetectZone = Zone.current.fork(parentDetectSpec).fork({
+    name: 'child',
+    onScheduleTask: function(delegate, curr, target, task) {
+      return delegate.scheduleTask(target, task);
+    },
+    onInvokeTask: function(delegate, curr, target, task, applyThis, applyArgs) {
+      return delegate.invokeTask(target, task, applyThis, applyArgs);
+    },
+    onCancelTask: function(delegate, curr, target, task) {
+      return delegate.cancelTask(target, task);
+    },
+    onInvoke: function(delegate, curr, target, callback, applyThis, applyArgs, source) {
+      return delegate.invoke(target, callback, applyThis, applyArgs, source);
+    }
+  });
+
+  Error.stackTraceLimit = 100;
+  childDetectZone.run(() => {
+    childDetectZone.runGuarded(() => {
+      const fakeTransitionTo =
+          (toState: TaskState, fromState1: TaskState, fromState2: TaskState) => {};
+      childDetectZone.scheduleEventTask(
+          'detect',
+          () => {
+            childDetectZone.scheduleMacroTask(
+                'detect',
+                () => {
+                  childDetectZone.scheduleMicroTask(
+                      'detect',
+                      () => {
+                        const error = new Error('detect');
+                        const frames = error.stack.split('\n');
+                        while (frames.length) {
+                          let frame = frames.shift();
+                          blackListedStackFrames[frame] = FrameType.blackList;
+                        }
+                      },
+                      null,
+                      (t: Task) => {
+                        (t as any)._transitionTo = fakeTransitionTo;
+                        t.invoke();
+                      });
+                },
+                null,
+                (t) => {
+                  (t as any)._transitionTo = fakeTransitionTo;
+                  t.invoke();
+                },
+                () => {});
+          },
+          null,
+          (t) => {
+            (t as any)._transitionTo = fakeTransitionTo;
+            t.invoke();
+          },
+          () => {});
+    });
+  });
+  Error.stackTraceLimit = 15;
+
   // carefully constructor a stack frame which contains all of the frames of interest which
   // need to be detected and blacklisted.
   let detectRunFn = () => {

test/common/Error.spec.ts

@@ -258,12 +258,161 @@ describe('ZoneAwareError', () => {
       expect(outsideFrames[0]).toMatch(/testFn.*[<root>]/);
 
       expect(insideFrames[0]).toMatch(/insideRun.*[InnerZone]]/);
-      expect(insideFrames[2]).toMatch(/testFn.*[<root>]]/);
+      expect(insideFrames[1]).toMatch(/testFn.*[<root>]]/);
 
       expect(outsideWithoutNewFrames[0]).toMatch(/testFn.*[<root>]/);
 
       expect(insideWithoutNewFrames[0]).toMatch(/insideRun.*[InnerZone]]/);
-      expect(insideWithoutNewFrames[2]).toMatch(/testFn.*[<root>]]/);
+      expect(insideWithoutNewFrames[1]).toMatch(/testFn.*[<root>]]/);
     }
   });
+
+  const zoneAwareFrames = [
+    'Zone.run', 'Zone.runGuarded', 'Zone.scheduleEventTask', 'Zone.scheduleMicroTask',
+    'Zone.scheduleMacroTask', 'Zone.runTask', 'ZoneDelegate.scheduleTask',
+    'ZoneDelegate.invokeTask', 'zoneAwareAddListener'
+  ];
+
+  function assertStackDoesNotContainZoneFrames(err: Error) {
+    const frames = err.stack.split('\n');
+    for (let i = 0; i < frames.length; i++) {
+      expect(zoneAwareFrames.filter(f => frames[i].indexOf(f) !== -1)).toEqual([]);
+    }
+  };
+
+  const errorZoneSpec = {
+    name: 'errorZone',
+    done: <() => void>null,
+    onHandleError:
+        (parentDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, error: Error) => {
+          assertStackDoesNotContainZoneFrames(error);
+          setTimeout(() => {
+            errorZoneSpec.done && errorZoneSpec.done();
+          }, 0);
+          return false;
+        }
+  };
+
+  const errorZone = Zone.root.fork(errorZoneSpec);
+
+  const assertStackDoesNotContainZoneFramesTest = function(testFn: Function) {
+    return function(done: () => void) {
+      errorZoneSpec.done = done;
+      errorZone.run(testFn);
+    };
+  };
+
+  describe('Error stack', () => {
+    it('Error with new which occurs in setTimeout callback should not have zone frames visible',
+       assertStackDoesNotContainZoneFramesTest(() => {
+         setTimeout(() => {
+           throw new Error('timeout test error');
+         }, 10);
+       }));
+
+    it('Error without new which occurs in setTimeout callback should not have zone frames visible',
+       assertStackDoesNotContainZoneFramesTest(() => {
+         setTimeout(() => {
+           throw Error('test error');
+         }, 10);
+       }));
+
+    it('Error with new which cause by promise rejection should not have zone frames visible',
+       (done) => {
+         const p = new Promise((resolve, reject) => {
+           reject(new Error('test error'));
+         });
+         p.catch(err => {
+           assertStackDoesNotContainZoneFrames(err);
+           done();
+         });
+       });
+
+    it('Error without new which cause by promise rejection should not have zone frames visible',
+       (done) => {
+         const p = new Promise((resolve, reject) => {
+           reject(Error('test error'));
+         });
+         p.catch(err => {
+           assertStackDoesNotContainZoneFrames(err);
+           done();
+         });
+       });
+
+    it('Error with new which occurs in eventTask callback should not have zone frames visible',
+       assertStackDoesNotContainZoneFramesTest(() => {
+         const task = Zone.current.scheduleEventTask('errorEvent', () => {
+           throw new Error('test error');
+         }, null, () => null, null);
+         task.invoke();
+       }));
+
+    it('Error without new which occurs in eventTask callback should not have zone frames visible',
+       assertStackDoesNotContainZoneFramesTest(() => {
+         const task = Zone.current.scheduleEventTask('errorEvent', () => {
+           throw Error('test error');
+         }, null, () => null, null);
+         task.invoke();
+       }));
+
+    it('Error with new which occurs in longStackTraceZone should not have zone frames and longStackTraceZone frames visible',
+       assertStackDoesNotContainZoneFramesTest(() => {
+         const task = Zone.current.fork((Zone as any)['longStackTraceZoneSpec'])
+                          .scheduleEventTask('errorEvent', () => {
+                            throw new Error('test error');
+                          }, null, () => null, null);
+         task.invoke();
+       }));
+
+    it('Error without new which occurs in longStackTraceZone should not have zone frames and longStackTraceZone frames visible',
+       assertStackDoesNotContainZoneFramesTest(() => {
+         const task = Zone.current.fork((Zone as any)['longStackTraceZoneSpec'])
+                          .scheduleEventTask('errorEvent', () => {
+                            throw Error('test error');
+                          }, null, () => null, null);
+         task.invoke();
+       }));
+
+    it('stack frames of the callback in user customized zoneSpec should be kept',
+       assertStackDoesNotContainZoneFramesTest(() => {
+         const task = Zone.current.fork((Zone as any)['longStackTraceZoneSpec'])
+                          .fork({
+                            name: 'customZone',
+                            onScheduleTask: (parentDelegate, currentZone, targetZone, task) => {
+                              return parentDelegate.scheduleTask(targetZone, task);
+                            },
+                            onHandleError: (parentDelegate, currentZone, targetZone, error) => {
+                              parentDelegate.handleError(targetZone, error);
+                              const containsCustomZoneSpecStackTrace =
+                                  error.stack.indexOf('onScheduleTask') !== -1;
+                              expect(containsCustomZoneSpecStackTrace).toBeTruthy();
+                              return false;
+                            }
+                          })
+                          .scheduleEventTask('errorEvent', () => {
+                            throw new Error('test error');
+                          }, null, () => null, null);
+         task.invoke();
+       }));
+
+    it('should be able to generate zone free stack even NativeError stack is readonly', function() {
+      const _global: any =
+          typeof window === 'object' && window || typeof self === 'object' && self || global;
+      const NativeError = _global['__zone_symbol__Error'];
+      const desc = Object.getOwnPropertyDescriptor(NativeError.prototype, 'stack');
+      if (desc) {
+        const originalSet: (value: any) => void = desc.set;
+        // make stack readonly
+        desc.set = null;
+
+        try {
+          const error = new Error('test error');
+          expect(error.stack).toBeTruthy();
+          assertStackDoesNotContainZoneFrames(error);
+        } finally {
+          desc.set = originalSet;
+        }
+      }
+    });
+  });
 });