blob: c6c98bdcdc01d469259a406e596644f779c69fab [file] [log] [blame]
// Copyright (C) 2021 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This file should not import anything else. Since the flags will be used from
// ~everywhere and the are "statically" initialized (i.e. files construct Flags
// at import time) if this file starts importing anything we will quickly run
// into issues with initialization order which will be a pain.
interface FlagSettings {
id: string;
defaultValue: boolean;
description: string;
name?: string;
devOnly?: boolean;
}
export enum OverrideState {
DEFAULT = 'DEFAULT',
TRUE = 'OVERRIDE_TRUE',
FALSE = 'OVERRIDE_FALSE',
}
export interface FlagStore {
load(): object;
save(o: object): void;
}
// Stored state for a number of flags.
interface FlagOverrides {
[id: string]: OverrideState;
}
// Check if the given object is a valid FlagOverrides.
// This is necessary since someone could modify the persisted flags
// behind our backs.
function isFlagOverrides(o: object): o is FlagOverrides {
const states =
[OverrideState.TRUE.toString(), OverrideState.FALSE.toString()];
for (const v of Object.values(o)) {
if (typeof v !== 'string' || !states.includes(v)) {
return false;
}
}
return true;
}
class Flags {
private store: FlagStore;
private flags: Map<string, FlagImpl>;
private overrides: FlagOverrides;
constructor(store: FlagStore) {
this.store = store;
this.flags = new Map();
this.overrides = {};
this.load();
}
register(settings: FlagSettings): Flag {
const id = settings.id;
if (this.flags.has(id)) {
throw new Error(`Flag with id "${id}" is already registered.`);
}
const saved = this.overrides[id];
const state = saved === undefined ? OverrideState.DEFAULT : saved;
const flag = new FlagImpl(this, state, settings);
this.flags.set(id, flag);
return flag;
}
allFlags(): Flag[] {
const includeDevFlags =
['127.0.0.1', '::1', 'localhost'].includes(window.location.hostname);
let flags = [...this.flags.values()];
flags = flags.filter((flag) => includeDevFlags || !flag.devOnly);
flags.sort((a, b) => a.name.localeCompare(b.name));
return flags;
}
resetAll() {
for (const flag of this.flags.values()) {
flag.state = OverrideState.DEFAULT;
}
this.save();
}
load(): void {
const o = this.store.load();
if (isFlagOverrides(o)) {
this.overrides = o;
}
}
save(): void {
for (const flag of this.flags.values()) {
if (flag.isOverridden()) {
this.overrides[flag.id] = flag.state;
} else {
delete this.overrides[flag.id];
}
}
this.store.save(this.overrides);
}
}
export interface Flag {
// A unique identifier for this flag ("magicSorting")
readonly id: string;
// The name of the flag the user sees ("New track sorting algorithm")
readonly name: string;
// A longer description which is displayed to the user.
// "Sort tracks using an embedded tfLite model based on your expression
// while waiting for the trace to load."
readonly description: string;
// Whether the flag defaults to true or false.
// If !flag.isOverridden() then flag.get() === flag.defaultValue
readonly defaultValue: boolean;
// Get the current value of the flag.
get(): boolean;
// Override the flag and persist the new value.
set(value: boolean): void;
// If the flag has been overridden.
// Note: A flag can be overridden to its default value.
isOverridden(): boolean;
// Reset the flag to its default setting.
reset(): void;
// Get the current state of the flag.
overriddenState(): OverrideState;
}
class FlagImpl implements Flag {
registry: Flags;
state: OverrideState;
readonly id: string;
readonly name: string;
readonly description: string;
readonly defaultValue: boolean;
readonly devOnly: boolean;
constructor(registry: Flags, state: OverrideState, settings: FlagSettings) {
this.registry = registry;
this.id = settings.id;
this.state = state;
this.description = settings.description;
this.defaultValue = settings.defaultValue;
this.name = settings.name || settings.id;
this.devOnly = settings.devOnly || false;
}
get(): boolean {
switch (this.state) {
case OverrideState.TRUE:
return true;
case OverrideState.FALSE:
return false;
case OverrideState.DEFAULT:
default:
return this.defaultValue;
}
}
set(value: boolean): void {
const next = value ? OverrideState.TRUE : OverrideState.FALSE;
if (this.state === next) {
return;
}
this.state = next;
this.registry.save();
}
overriddenState(): OverrideState {
return this.state;
}
reset() {
this.state = OverrideState.DEFAULT;
this.registry.save();
}
isOverridden(): boolean {
return this.state !== OverrideState.DEFAULT;
}
}
class LocalStorageStore implements FlagStore {
static KEY = 'perfettoFeatureFlags';
load(): object {
const s = localStorage.getItem(LocalStorageStore.KEY);
let parsed: object;
try {
parsed = JSON.parse(s || '{}');
} catch (e) {
return {};
}
if (typeof parsed !== 'object' || parsed === null) {
return {};
}
return parsed;
}
save(o: object): void {
const s = JSON.stringify(o);
localStorage.setItem(LocalStorageStore.KEY, s);
}
}
export const FlagsForTesting = Flags;
export const featureFlags = new Flags(new LocalStorageStore());
export const PERF_SAMPLE_FLAG = featureFlags.register({
id: 'perfSampleFlamegraph',
name: 'Perf Sample Flamegraph',
description: 'Show flamegraph generated by a perf sample.',
defaultValue: true,
});
export const RECORDING_V2_FLAG = featureFlags.register({
id: 'recordingv2',
name: 'Recording V2',
description: 'Record using V2 interface',
defaultValue: false,
});