STASH

Author: lobsterkatie

packages/types/src/span.ts

@@ -188,3 +188,27 @@ export type TraceHeadersObj = {
   'sentry-trace': string;
   tracestate?: string;
 };
+
+// type SentryTraceHeader = ['sentry-trace', string];
+// type TracestateHeader = ['tracestate', string];
+// export type TraceHeadersArr = [SentryTraceHeader, TracestateHeader?];
+// const enum TraceHeaderNames {
+//   'sentry-trace' = 'sentry_trace',
+//   tracestate = 'tracestate',
+// }
+
+// type TraceHeaderName = 'sentry-trace' | 'tracestate';
+
+// type TraceHeaders = Array<[TraceHeaderName, string]> | Record<TraceHeaderName, string>;
+
+// const x:SentryTraceHeader = ['hi', 'hi']
+// const y:TracestateHeader = [5, 'hi']
+// export type TraceHeadersArr = [['sentry-trace', string], ['tracestate', string]?];
+// export type TraceHeaders = TraceHeadersArr | TraceHeadersObj;
+// const x: TraceHeaders = [['sentry-trace', 'string']];
+// const y: TraceHeaders = [
+//   ['sentry-trace', 'string'],
+//   ['tracestate', 'string'],
+// ];
+// y['sentry-trace']
+// // const x: TraceHeaders = [['sentry-trace', "string"], ...(true && ['tracestate', "string"])]

packages/utils/src/encodings_messing_around.py

@@ -0,0 +1,56 @@
+sample_string = "GeeksForGeeks is the best"
+sample_string_bytes = sample_string.encode("ascii")
+
+base64_bytes = base64.b64encode(sample_string_bytes)
+base64_string = base64_bytes.decode("ascii")
+
+x = (base64.b64encode(sample_string_bytes)).decode("ascii")
+base64_string = (base64.b64encode(sample_string.encode("ascii"))).decode("ascii")
+
+print(sample_string_bytes, base64_bytes, base64_string, x, y)
+
+
+base64_bytes = base64_string.encode("ascii")
+
+sample_string_bytes = base64.b64decode(base64_bytes)
+sample_string = sample_string_bytes.decode("ascii")
+
+z = (base64.b64decode(base64_bytes)).decode("ascii")
+base64_string = (base64.b64encode(sample_string.encode("ascii"))).decode("ascii")
+sample_string = (base64.b64decode(base64_string.encode("ascii"))).decode("ascii")
+
+print(base64_bytes, sample_string_bytes, sample_string, z, a)
+
+def tob64(orig, encoding):
+  # print orig.decode(encoding)
+  # # print orig.encode(encoding)
+  # print base64.b64encode(orig)
+  # print base64.b64encode(orig).encode("ascii")
+  # print base64.b64encode(orig.decode(encoding))
+  return (base64.b64encode(orig.decode(encoding))).encode("ascii")
+
+def fromb64(b64, encoding):
+  print b64
+  # print b64.encode("ascii")
+  print base64.b64decode(b64)
+  print base64.b64decode(b64).decode(encoding)
+  return (base64.b64decode(b64.encode("ascii"))).decode(encoding)
+
+def tester():
+  ascii_string = "this is a test 123"
+  base64_string = tob64(ascii_string, "ascii")
+  new_ascii_string = fromb64(base64_string, "ascii")
+  print("ascii:", ascii_string, base64_string, new_ascii_string)
+  base64_string = tob64(ascii_string, "UTF-8")
+  new_ascii_string = fromb64(base64_string, "UTF-8")
+  print("UTF-8:", ascii_string, base64_string, new_ascii_string)
+  dog_string = "🐶"
+  # base64_string = tob64(dog_string, "ascii")
+  # new_dog_string = fromb64(base64_string, "ascii")
+  # print("ascii:", dog_string, base64_string, new_dog_string)
+  # base64_string = tob64(dog_string, "UTF-8")
+  base64_string = base64.b64encode(dog_string)
+  new_dog_string = fromb64(base64_string, "UTF-8")
+  print("UTF-8:", dog_string, base64_string, new_dog_string)
+
+tester()

packages/utils/src/string.ts

@@ -214,3 +214,35 @@ export function unicodeToBase64(unicodeString: string): string {
 
   throw new SentryError(errMsg);
 }
+
+// let unicode = 'dogs are great ♥️🐶';
+let unicode = JSON.stringify({
+  environment: 'dogpark🐶🌳',
+  public_key: 'dogsarebadatkeepingsecrets',
+  release: 'off.leash.park',
+  trace_id: '0908201304152013',
+});
+let binary = unicodeToBinary(unicode);
+let base64 = Buffer.from(binary, 'binary').toString('base64');
+
+console.log(unicode);
+console.log(binary);
+console.log(base64);
+
+binary = Buffer.from(base64, 'base64').toString('binary');
+unicode = binaryToUnicode(binary);
+
+console.log(binary);
+console.log(unicode);
+
+console.log('------');
+
+console.log(unicode);
+
+base64 = Buffer.from(unicode, 'utf16le').toString('base64');
+
+console.log(base64);
+
+unicode = Buffer.from(base64, 'base64').toString('utf16le');
+
+console.log(unicode);

packages/utils/test/string.test.ts

@@ -1,14 +1,20 @@
-import { isMatchingPattern, truncate } from '../src/string';
+import { BASE64_REGEX, base64ToUnicode, isMatchingPattern, truncate, unicodeToBase64 } from '../src/string';
 
 describe('truncate()', () => {
   test('it works as expected', () => {
-    expect(truncate(null, 3)).toEqual(null);
     expect(truncate('lolol', 3)).toEqual('lol...');
     expect(truncate('lolol', 10)).toEqual('lolol');
     expect(truncate('1'.repeat(1000), 300)).toHaveLength(303);
     expect(truncate(new Array(1000).join('f'), 0)).toEqual(new Array(1000).join('f'));
     expect(truncate(new Array(1000).join('f'), 0)).toEqual(new Array(1000).join('f'));
   });
+
+  test('should bail out as an identity function when given non-string value', () => {
+    expect(truncate(null as any, 3)).toEqual(null);
+    expect(truncate(undefined as any, 3)).toEqual(undefined);
+    expect(truncate({} as any, 3)).toEqual({});
+    expect(truncate([] as any, 3)).toEqual([]);
+  });
 });
 
 describe('isMatchingPattern()', () => {
@@ -33,9 +39,32 @@ describe('isMatchingPattern()', () => {
   });
 
   test('should bail out with false when given non-string value', () => {
-    expect(isMatchingPattern(null, 'foo')).toEqual(false);
-    expect(isMatchingPattern(undefined, 'foo')).toEqual(false);
-    expect(isMatchingPattern({}, 'foo')).toEqual(false);
-    expect(isMatchingPattern([], 'foo')).toEqual(false);
+    expect(isMatchingPattern(null as any, 'foo')).toEqual(false);
+    expect(isMatchingPattern(undefined as any, 'foo')).toEqual(false);
+    expect(isMatchingPattern({} as any, 'foo')).toEqual(false);
+    expect(isMatchingPattern([] as any, 'foo')).toEqual(false);
+  });
+});
+
+describe('base64ToUnicode/unicodeToBase64', () => {
+  const unicodeString = 'Dogs are great!';
+  const base64String = 'RABvAGcAcwAgAGEAcgBlACAAZwByAGUAYQB0ACEA';
+
+  test('converts to valid base64', () => {
+    expect(BASE64_REGEX.test(unicodeToBase64(unicodeString))).toBe(true);
+  });
+
+  test('works as expected', () => {
+    expect(unicodeToBase64(unicodeString)).toEqual(base64String);
+    expect(base64ToUnicode(base64String)).toEqual(unicodeString);
+  });
+
+  test('conversion functions are inverses', () => {
+    expect(base64ToUnicode(unicodeToBase64(unicodeString))).toEqual(unicodeString);
+    expect(unicodeToBase64(base64ToUnicode(base64String))).toEqual(base64String);
+  });
+
+  it('throws an error when given invalid value', () => {
+    expect(unicodeToBase64(null as any)).toThrowError("isn't a string");
   });
 });