@bitblit/ratchet-aws 6.0.146-alpha → 6.0.148-alpha

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@bitblit/ratchet-aws",
-  "version": "6.0.146-alpha",
+  "version": "6.0.148-alpha",
   "description": "Common tools for use with AWS browser and node",
   "sideEffects": false,
   "type": "module",
   "files": [
+    "src/**",
     "lib/**",
     "bin/**"
   ],
@@ -51,7 +52,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@bitblit/ratchet-common": "6.0.146-alpha"
+    "@bitblit/ratchet-common": "6.0.148-alpha"
   },
   "optionalDependencies": {
     "@aws-sdk/client-athena": "3.922.0",
@@ -99,7 +100,7 @@
     "@aws-sdk/lib-storage": "^3.922.0",
     "@aws-sdk/s3-request-presigner": "^3.922.0",
     "@aws-sdk/types": "^3.922.0",
-    "@bitblit/ratchet-common": "6.0.146-alpha",
+    "@bitblit/ratchet-common": "6.0.148-alpha",
     "@smithy/abort-controller": "^4.2.4",
     "@smithy/smithy-client": "^4.9.2",
     "@smithy/util-waiter": "^4.2.4"
@@ -176,7 +177,7 @@
     }
   },
   "devDependencies": {
-    "@bitblit/ratchet-node-only": "6.0.146-alpha",
+    "@bitblit/ratchet-node-only": "6.0.148-alpha",
     "@types/aws-lambda": "8.10.157",
     "aws-sdk-client-mock": "4.1.0"
   }

package/src/batch/aws-batch-background-processor.spec.ts

@@ -0,0 +1,22 @@
+import { AwsBatchRatchet } from './aws-batch-ratchet.js';
+import { SubmitJobCommandOutput } from '@aws-sdk/client-batch';
+import { AwsBatchBackgroundProcessor } from './aws-batch-background-processor.js';
+import { beforeEach, describe, expect, test } from 'vitest';
+import { mock, MockProxy } from 'vitest-mock-extended';
+
+let mockBatchRatchet: MockProxy<AwsBatchRatchet>;
+
+describe('#AwsBatchBackgroundProcessor', () => {
+  beforeEach(() => {
+    mockBatchRatchet = mock<AwsBatchRatchet>();
+  });
+
+  test('Should schedule background task', async () => {
+    //mockBatchRatchet.defaultQueueName = 'a';
+    mockBatchRatchet.scheduleJob.mockResolvedValue({ jobId: 'newID', jobName: 'name', $metadata: null });
+    const svc: AwsBatchBackgroundProcessor = new AwsBatchBackgroundProcessor(mockBatchRatchet, null);
+
+    const res: SubmitJobCommandOutput = await svc.scheduleBackgroundTask('BACKGROUND_TASK_NAME', {}, {});
+    expect(res).not.toBeNull();
+  });
+});

package/src/batch/aws-batch-background-processor.ts

@@ -0,0 +1,71 @@
+import { SubmitJobCommandInput, SubmitJobCommandOutput } from '@aws-sdk/client-batch';
+import { DateTime } from 'luxon';
+import { AwsBatchRatchet } from './aws-batch-ratchet.js';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+
+/**
+ * Class to simplify using AWS batch as a background processor
+ * (Primarily used by Epsilon)
+ */
+export class AwsBatchBackgroundProcessor {
+  constructor(
+    private batchRatchet: AwsBatchRatchet,
+    private validTaskNames?: string[],
+  ) {
+    RequireRatchet.notNullOrUndefined(this.batchRatchet, 'batchRatchet');
+    RequireRatchet.notNullOrUndefined(this.batchRatchet.batchClient, 'batchRatchet.batchClient');
+    RequireRatchet.notNullOrUndefined(this.batchRatchet.defaultJobDefinition, 'batchRatchet.defaultJobDefinition');
+    RequireRatchet.notNullOrUndefined(this.batchRatchet.defaultQueueName, 'batchRatchet.defaultQueueName');
+  }
+
+  public async scheduleBackgroundTask(
+    taskName: string,
+    data: Record<string, any> = {},
+    meta: Record<string, any> = {},
+  ): Promise<SubmitJobCommandOutput> {
+    if (
+      this.validTaskNames &&
+      this.validTaskNames.length &&
+      (!StringRatchet.trimToNull(taskName) || !this.validTaskNames.includes(taskName))
+    ) {
+      ErrorRatchet.throwFormattedErr('Cannot start task %s - not found in valid task list', taskName);
+    }
+
+    Logger.info('Submitting background task to AWS batch: %s %j %s', taskName, data, this.batchRatchet.defaultQueueName);
+
+    let rval: SubmitJobCommandOutput = null;
+
+    const jobName: string = `${this.batchRatchet.defaultJobDefinition}-${taskName}_${DateTime.utc().toFormat('yyyy-MM-dd-HH-mm')}`;
+
+    const options: SubmitJobCommandInput = {
+      jobName: jobName,
+      jobDefinition: this.batchRatchet.defaultJobDefinition,
+      jobQueue: this.batchRatchet.defaultQueueName,
+      parameters: {
+        taskName,
+        taskData: JSON.stringify(data),
+        taskMetadata: JSON.stringify(meta),
+      },
+    };
+
+    try {
+      rval = await this.batchRatchet.scheduleJob(options);
+      Logger.info('Job %s(%s) submitted', rval.jobName, rval.jobId);
+    } catch (err) {
+      Logger.error(
+        'Cannot submit batch job taskName: %s jobDef: %s queue: %s jobName: %s data: %j',
+        taskName,
+        this.batchRatchet.defaultJobDefinition,
+        this.batchRatchet.defaultQueueName,
+        jobName,
+        data,
+        err,
+      );
+    }
+
+    return rval;
+  }
+}

package/src/batch/aws-batch-ratchet.spec.ts

@@ -0,0 +1,42 @@
+import { AwsBatchRatchet } from './aws-batch-ratchet.js';
+import { BatchClient, JobStatus, JobSummary, ListJobsCommand, SubmitJobCommand, SubmitJobCommandOutput } from '@aws-sdk/client-batch';
+import { mockClient } from 'aws-sdk-client-mock';
+import { beforeEach, describe, expect, test } from 'vitest';
+
+let mockBatch;
+
+describe('#AwsBatchService', () => {
+  mockBatch = mockClient(BatchClient);
+  beforeEach(() => {
+    mockBatch.reset();
+  });
+
+  test('Should schedule batch job', async () => {
+    const svc: AwsBatchRatchet = new AwsBatchRatchet(mockBatch);
+    mockBatch.on(SubmitJobCommand).resolves({ jobName: 'b' });
+
+    const res: SubmitJobCommandOutput = await svc.scheduleJob({
+      jobName: 'testName',
+      jobDefinition: 'testDefinition',
+      jobQueue: 'testQueue',
+    });
+    expect(res).not.toBeNull();
+  });
+
+  test('Should list jobs', async () => {
+    const svc: AwsBatchRatchet = new AwsBatchRatchet(mockBatch);
+    mockBatch.on(ListJobsCommand).resolves([{}] as JobSummary[]);
+
+    const res: JobSummary[] = await svc.listJobs('testQueue');
+    expect(res).not.toBeNull();
+    expect(res.length).toEqual(1);
+  });
+
+  test('Should count jobs in state', async () => {
+    const svc: AwsBatchRatchet = new AwsBatchRatchet(mockBatch);
+    mockBatch.on(ListJobsCommand).resolves([{}] as JobSummary[]);
+
+    const res: number = await svc.jobCountInState(JobStatus.RUNNABLE, 'testQueue');
+    expect(res).toEqual(1);
+  });
+});

package/src/batch/aws-batch-ratchet.ts

@@ -0,0 +1,70 @@
+import {
+  BatchClient,
+  JobStatus,
+  JobSummary,
+  ListJobsCommand,
+  ListJobsCommandInput,
+  ListJobsCommandOutput,
+  SubmitJobCommand,
+  SubmitJobCommandInput,
+  SubmitJobCommandOutput,
+} from '@aws-sdk/client-batch';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+
+/**
+ * Ratchet for simplifying interacting with AWS Batch
+ */
+export class AwsBatchRatchet {
+  constructor(
+    private _batchClient: BatchClient,
+    private _defaultQueueName?: string,
+    private _defaultJobDefinition?: string,
+  ) {}
+
+  public get batchClient(): BatchClient {
+    return this._batchClient;
+  }
+  public get defaultQueueName(): string {
+    return this._defaultQueueName;
+  }
+  public get defaultJobDefinition(): string {
+    return this._defaultJobDefinition;
+  }
+
+  public async scheduleJob(options: SubmitJobCommandInput): Promise<SubmitJobCommandOutput> {
+    Logger.info('Submitting batch job %s', options.jobName);
+    try {
+      const rval: SubmitJobCommandOutput = await this._batchClient.send(new SubmitJobCommand(options));
+      Logger.info('Job %s(%s) submitted', rval.jobName, rval.jobId);
+      return rval;
+    } catch (err) {
+      Logger.error('Cannot submit batch job %s: %s', options.jobName, err);
+    }
+    return null;
+  }
+
+  public async jobCountInState(jobStatus: JobStatus, queueName: string = this.defaultQueueName): Promise<number> {
+    const all: JobSummary[] = await this.listJobs(queueName, jobStatus);
+    return all.length;
+  }
+
+  public async listJobs(queueName: string = this.defaultQueueName, jobStatus: JobStatus = null): Promise<JobSummary[]> {
+    RequireRatchet.notNullOrUndefined(queueName, 'queueName');
+    let rval: JobSummary[] = [];
+    const request: ListJobsCommandInput = {
+      jobQueue: queueName,
+      jobStatus: jobStatus,
+      nextToken: null,
+    };
+    Logger.info('Fetching %j', request);
+    do {
+      Logger.info('Pulling page...');
+      const tmp: ListJobsCommandOutput = await this._batchClient.send(new ListJobsCommand(request));
+      rval = rval.concat(tmp.jobSummaryList);
+      request.nextToken = tmp.nextToken;
+    } while (request.nextToken);
+
+    return rval;
+  }
+}

package/src/build/ratchet-aws-info.ts

@@ -0,0 +1,19 @@
+import { BuildInformation } from '@bitblit/ratchet-common/build/build-information';
+
+export class RatchetAwsInfo {
+  // Empty constructor prevents instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static buildInformation(): BuildInformation {
+    const val: BuildInformation = {
+      version: 'LOCAL-SNAPSHOT',
+      hash: 'LOCAL-HASH',
+      branch: 'LOCAL-BRANCH',
+      tag: 'LOCAL-TAG',
+      timeBuiltISO: 'LOCAL-TIME-ISO',
+      notes: 'LOCAL-NOTES',
+    };
+    return val;
+  }
+}

package/src/cache/memory-storage-provider.ts

@@ -0,0 +1,39 @@
+/*
+  Simple memory-based version, mainly for testing
+*/
+
+import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper.js';
+import { SimpleCacheStorageProvider } from './simple-cache-storage-provider.js';
+
+export class MemoryStorageProvider implements SimpleCacheStorageProvider {
+  private _cache: Map<string, SimpleCacheObjectWrapper<any>> = new Map<string, SimpleCacheObjectWrapper<any>>();
+
+  public async readFromCache<T>(cacheKey: string): Promise<SimpleCacheObjectWrapper<T>> {
+    return this._cache.get(cacheKey);
+  }
+
+  public async storeInCache<T>(value: SimpleCacheObjectWrapper<T>): Promise<boolean> {
+    let rval: boolean = false;
+    if (value?.cacheKey) {
+      this._cache.set(value.cacheKey, value);
+      rval = true;
+    }
+    return rval;
+  }
+
+  public async removeFromCache(cacheKey: string): Promise<void> {
+    if (cacheKey) {
+      this._cache.delete(cacheKey);
+    }
+  }
+
+  public async clearCache(): Promise<number> {
+    const rval: number = this._cache.size;
+    this._cache = new Map<string, SimpleCacheObjectWrapper<any>>();
+    return rval;
+  }
+
+  public async readAll(): Promise<SimpleCacheObjectWrapper<any>[]> {
+    return Array.from(this._cache.values());
+  }
+}

package/src/cache/simple-cache-object-wrapper.ts

@@ -0,0 +1,11 @@
+/*
+  Wraps an object to be stored in the cache along with the cache data needed to store/filter it
+*/
+
+export interface SimpleCacheObjectWrapper<T> {
+  cacheKey: string;
+  createdEpochMS: number;
+  expiresEpochMS: number;
+  value: T;
+  generated: boolean;
+}

package/src/cache/simple-cache-read-options.ts

@@ -0,0 +1,9 @@
+/*
+    Controls how the object will be read from cache
+*/
+
+export interface SimpleCacheReadOptions {
+  maxStalenessMS: number;
+  timeToLiveMS: number;
+  cacheNullValues: boolean;
+}

package/src/cache/simple-cache-storage-provider.ts

@@ -0,0 +1,15 @@
+/*
+  Objects implementing this interface can store and retrieve objects in a cache, using a read-thru
+  approach.
+*/
+
+import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper.js';
+
+export interface SimpleCacheStorageProvider {
+  // Reads the object from the cache and returns the wrapper.  If the
+  readFromCache<T>(cacheKey: string): Promise<SimpleCacheObjectWrapper<T>>;
+  storeInCache<T>(value: SimpleCacheObjectWrapper<T>): Promise<boolean>;
+  removeFromCache(cacheKey: string): Promise<void>;
+  clearCache(): Promise<number>;
+  readAll(): Promise<SimpleCacheObjectWrapper<any>[]>;
+}

package/src/cache/simple-cache.spec.ts

@@ -0,0 +1,42 @@
+import { SimpleCache } from './simple-cache.js';
+import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper.js';
+import { describe, expect, test } from 'vitest';
+import { MemoryStorageProvider } from './memory-storage-provider.js';
+
+describe('#simpleCache', function () {
+  test.skip('should read/write/delete with a memory', async () => {
+    const storageProvider: MemoryStorageProvider = new MemoryStorageProvider();
+
+    const simpleCache: SimpleCache = new SimpleCache(storageProvider, 2000000);
+
+    await simpleCache.removeFromCache('test1'); // Make sure clear
+
+    const test1a: SimpleCacheObjectWrapper<any> = await simpleCache.fetchWrapper<any>('test1', () => Promise.resolve({ x: 1 }));
+    expect(test1a).not.toBeNull();
+    expect(test1a.generated).toBeTruthy();
+    expect(test1a.value).not.toBeNull();
+    expect(test1a.value['x']).toEqual(1);
+
+    const test1b: SimpleCacheObjectWrapper<any> = await simpleCache.fetchWrapper<any>('test1', () => Promise.resolve({ x: 1 }));
+    expect(test1b).not.toBeNull();
+    expect(test1b.generated).toBeFalsy();
+    expect(test1b.value).not.toBeNull();
+    expect(test1b.value['x']).toEqual(1);
+
+    await simpleCache.removeFromCache('test1'); // Make sure clear
+  }, 60_000);
+
+  test.skip('should write a bunch', async () => {
+    const storageProvider: MemoryStorageProvider = new MemoryStorageProvider();
+    const simpleCache: SimpleCache = new SimpleCache(storageProvider, 1000);
+
+    for (let i = 0; i < 10; i++) {
+      const _tests: SimpleCacheObjectWrapper<any> = await simpleCache.fetchWrapper<any>('test' + i, () => Promise.resolve({ x: i }));
+    }
+
+    const all: SimpleCacheObjectWrapper<any>[] = await simpleCache.readAll();
+    expect(all).not.toBeNull();
+    expect(all.length).toBeGreaterThan(9);
+    await simpleCache.clearCache();
+  }, 60_000);
+});

package/src/cache/simple-cache.ts

@@ -0,0 +1,81 @@
+/*
+  Wraps up a simple cache storage provider and gives helper methods
+*/
+
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { SimpleCacheStorageProvider } from './simple-cache-storage-provider.js';
+import { SimpleCacheObjectWrapper } from './simple-cache-object-wrapper.js';
+import { SimpleCacheReadOptions } from './simple-cache-read-options.js';
+
+export class SimpleCache {
+  // Default 1 minute expiration
+  constructor(
+    private provider: SimpleCacheStorageProvider,
+    private defaultTimeToLiveMS: number = 1_000 * 60,
+  ) {}
+
+  public createDefaultReadOptions(): SimpleCacheReadOptions {
+    return {
+      maxStalenessMS: null,
+      timeToLiveMS: this.defaultTimeToLiveMS,
+      cacheNullValues: false,
+    };
+  }
+
+  public async fetchWrapper<T>(
+    cacheKey: string,
+    producer: () => Promise<T>,
+    opts: SimpleCacheReadOptions = this.createDefaultReadOptions(),
+  ): Promise<SimpleCacheObjectWrapper<T>> {
+    Logger.silly('Fetching %s', cacheKey);
+    const now: number = new Date().getTime();
+    let rval: SimpleCacheObjectWrapper<T> = await this.provider.readFromCache(cacheKey);
+    if (rval && rval.expiresEpochMS < now) {
+      Logger.debug('Object found, but expired - removing');
+      rval = null;
+    }
+    if (rval && opts && opts.maxStalenessMS && now - rval.createdEpochMS > opts.maxStalenessMS) {
+      Logger.debug('Object found by too stale - removing');
+      rval = null;
+    }
+    if (!rval) {
+      Logger.debug('%s not found in cache, generating', cacheKey);
+      const tmp: T = await producer();
+      if (tmp || opts?.cacheNullValues) {
+        Logger.debug('Writing %j to cache');
+        rval = {
+          cacheKey: cacheKey,
+          createdEpochMS: now,
+          expiresEpochMS: opts && opts.timeToLiveMS ? now + opts.timeToLiveMS : null,
+          value: tmp,
+          generated: false, // Always STORE false, overwrite it when it should be true
+        };
+        await this.provider.storeInCache(rval);
+        rval.generated = true;
+      }
+    }
+    return rval;
+  }
+
+  public async fetch<T>(cacheKey: string, producer: () => Promise<T>, opts: SimpleCacheReadOptions = null): Promise<T> {
+    const wrapper: SimpleCacheObjectWrapper<T> = await this.fetchWrapper(cacheKey, producer, opts);
+    return wrapper ? wrapper.value : null;
+  }
+
+  public async removeFromCache<T>(cacheKey: string, returnOldValue?: boolean): Promise<SimpleCacheObjectWrapper<T>> {
+    let rval: SimpleCacheObjectWrapper<T> = null;
+    if (returnOldValue) {
+      rval = await this.fetchWrapper(cacheKey, () => null);
+    }
+    await this.provider.removeFromCache(cacheKey);
+    return rval;
+  }
+
+  public async clearCache(): Promise<number> {
+    return this.provider.clearCache();
+  }
+
+  public async readAll(): Promise<SimpleCacheObjectWrapper<any>[]> {
+    return this.provider.readAll();
+  }
+}

package/src/cloudwatch/cloud-watch-log-group-ratchet.spec.ts

@@ -0,0 +1,26 @@
+import { CloudWatchLogsClient, DescribeLogStreamsCommand, DescribeLogStreamsCommandOutput } from '@aws-sdk/client-cloudwatch-logs';
+import { CloudWatchLogGroupRatchet } from './cloud-watch-log-group-ratchet.js';
+import { mockClient } from 'aws-sdk-client-mock';
+import { beforeEach, describe, expect, test } from 'vitest';
+
+let mockCW;
+
+describe('#CloudWatchLogGroupRatchet', function () {
+  mockCW = mockClient(CloudWatchLogsClient);
+  beforeEach(() => {
+    mockCW.reset();
+  });
+
+  test('should read log stream names', async () => {
+    mockCW.on(DescribeLogStreamsCommand).resolves({
+      logStreams: [{ logStreamName: '1' }, { logStreamName: '2' }],
+    } as DescribeLogStreamsCommandOutput);
+
+    const cw: CloudWatchLogGroupRatchet = new CloudWatchLogGroupRatchet('testGroup', mockCW);
+
+    const res: string[] = await cw.readLogStreamNames();
+
+    expect(res).toBeTruthy();
+    expect(res.length).toEqual(2);
+  });
+});

package/src/cloudwatch/cloud-watch-log-group-ratchet.ts

@@ -0,0 +1,105 @@
+import {
+  CloudWatchLogsClient,
+  DescribeLogStreamsCommand,
+  DescribeLogStreamsCommandInput,
+  DescribeLogStreamsCommandOutput,
+  FilteredLogEvent,
+  FilterLogEventsCommand,
+  FilterLogEventsCommandInput,
+  FilterLogEventsCommandOutput,
+  LogStream,
+} from '@aws-sdk/client-cloudwatch-logs';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { StopWatch } from '@bitblit/ratchet-common/lang/stop-watch';
+
+export class CloudWatchLogGroupRatchet {
+  constructor(
+    private logGroup: string,
+    private awsCWLogs: CloudWatchLogsClient = new CloudWatchLogsClient({ region: 'us-east-1' }),
+  ) {}
+
+  public get cloudWatchLogsClient(): CloudWatchLogsClient {
+    return this.awsCWLogs;
+  }
+  public async readLogStreams(startTimestamp: number = null, endTimestamp: number = null): Promise<LogStream[]> {
+    const params: DescribeLogStreamsCommandInput = {
+      logGroupName: this.logGroup,
+      // logStreamNamePrefix: prefix,
+      orderBy: 'LastEventTime',
+    };
+
+    const rval: LogStream[] = [];
+
+    do {
+      Logger.debug('Pulling more log streams (%d found so far)', rval.length);
+      const temp: DescribeLogStreamsCommandOutput = await this.awsCWLogs.send(new DescribeLogStreamsCommand(params));
+
+      temp.logStreams.forEach((s) => {
+        if (s.lastEventTimestamp !== null) {
+          if (!startTimestamp || s.lastEventTimestamp >= startTimestamp) {
+            if (!endTimestamp || s.firstEventTimestamp <= endTimestamp) {
+              rval.push(s);
+            }
+          }
+        }
+      });
+
+      params.nextToken = temp.nextToken;
+    } while (params.nextToken);
+
+    Logger.debug('Found %d total, returning', rval.length);
+    return rval;
+  }
+
+  public async readLogStreamNames(startTimestamp: number = null, endTimestamp: number = null): Promise<string[]> {
+    const streams: LogStream[] = await this.readLogStreams(startTimestamp, endTimestamp);
+    const rval: string[] = streams.map((s) => s.logStreamName);
+    return rval;
+  }
+
+  public async readEvents(
+    filter: string,
+    startTimestamp: number = null,
+    endTimestamp: number = null,
+    sortEvents = true,
+    maxEvents: number = null,
+  ): Promise<FilteredLogEvent[]> {
+    const sw: StopWatch = new StopWatch();
+    const params: FilterLogEventsCommandInput = {
+      logGroupName: this.logGroup,
+      endTime: endTimestamp,
+      startTime: startTimestamp,
+    };
+
+    if (filter) {
+      params.filterPattern = filter;
+    }
+
+    Logger.debug('Reading log events matching : %j', params);
+
+    let rval: FilteredLogEvent[] = [];
+
+    do {
+      Logger.debug('Pulling more log events (%d found so far) : %s', rval.length, sw.dump());
+      const temp: FilterLogEventsCommandOutput = await this.awsCWLogs.send(new FilterLogEventsCommand(params));
+      rval = rval.concat(temp.events);
+      params.nextToken = temp.nextToken;
+    } while (!!params.nextToken && (!maxEvents || rval.length < maxEvents));
+
+    Logger.debug('Found %d total in %s', rval.length, sw.dump());
+
+    if (sortEvents) {
+      Logger.debug('Sorting events by timestamp');
+      rval = rval.sort((a, b) => {
+        let rval = a.timestamp - b.timestamp;
+        if (rval === 0) {
+          rval = a.message.localeCompare(b.message);
+        }
+        return rval;
+      });
+    }
+
+    sw.log();
+    return rval;
+  }
+}