airbyte-faros-destination 0.1.53

package/lib/converters/squadcast/common.d.ts

@@ -0,0 +1,169 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { Converter, StreamContext } from '../converter';
+export declare type ApplicationMapping = Record<string, {
+    name: string;
+    platform?: string;
+}>;
+interface SquadcastConfig {
+    application_mapping?: ApplicationMapping;
+}
+export declare enum IncidentEventTypeCategory {
+    Created = "Created",
+    Acknowledged = "Acknowledged",
+    Resolved = "Resolved",
+    Custom = "Custom"
+}
+export declare enum IncidentStatusCategory {
+    Identified = "Identified",
+    Investigating = "Investigating",
+    Monitoring = "Monitoring",
+    Resolved = "Resolved",
+    Custom = "Custom"
+}
+export interface IncidentPriority {
+    category: IncidentPriorityCategory;
+    detail: string;
+}
+export declare enum IncidentPriorityCategory {
+    Critical = "Critical",
+    High = "High",
+    Medium = "Medium",
+    Low = "Low",
+    Custom = "Custom"
+}
+export declare enum IncidentSeverityCategory {
+    Sev1 = "Sev1",
+    Sev2 = "Sev2",
+    Sev3 = "Sev3",
+    Sev4 = "Sev4",
+    Sev5 = "Sev5",
+    Custom = "Custom"
+}
+export interface IncidentSeverity {
+    category: IncidentSeverityCategory;
+    detail: string;
+}
+interface Assignee {
+    id: string;
+    type: string;
+}
+interface Log {
+    action: string;
+    assignedTo: string;
+    id: string;
+    time: string;
+    reason: string;
+    additionalInfo: any | null;
+}
+declare type Tags = Record<string, Tag> | null;
+interface Tag {
+    value: string;
+    color: string;
+}
+export interface Event {
+    incident_id: string;
+    alert_source_id: string;
+    message: string;
+    description: string;
+    time_of_creation: string;
+    tags: Tags;
+    deduplication_reason?: {
+        matched_event_id: string;
+        evaluated_expression: string;
+        time_window: number;
+    };
+    payload: {
+        description: string;
+        event_id?: string;
+        message: string;
+        metric?: {
+            absolute: {
+                current_value: number;
+                threshold: number;
+                unit: string;
+            };
+            pod: string;
+            relative: {
+                current_value: number;
+                threshold: number;
+            };
+            time: string;
+        };
+        status?: string;
+        assignee?: {
+            id: string;
+            type: string;
+        };
+        created_by?: string;
+        tags?: Tags;
+    };
+}
+export interface Incident {
+    id: string;
+    title: string;
+    description: string;
+    status: string;
+    service: string;
+    alert_source: string;
+    assignee: string;
+    created_at: string;
+    acknowledged_at: string;
+    resolved_at: string;
+    tags: Tags;
+    event_count: number;
+    'tta (ms)': number;
+    'ttr (ms)': number;
+    logs: Log[];
+    url: string;
+}
+export interface Service {
+    id: string;
+    name: string;
+    slug: string;
+    email: string;
+    escalation_policy_id: string;
+    organization_id: string;
+    api_key: string;
+    description: string;
+    depends: any[] | null;
+    owner?: Assignee;
+    access_control: any | null;
+    on_maintenance: boolean;
+    escalation_policy: {
+        id: string;
+        name: string;
+        description: string;
+        slug: string;
+    };
+}
+export interface User {
+    id: string;
+    first_name: string;
+    last_name: string;
+    email: string;
+    contact: {
+        dial_code: string;
+        phone_number: string;
+    };
+    secondary_emails: string[];
+    email_verified: boolean;
+    phone_verified: boolean;
+    in_grace_period: boolean;
+    time_zone: string;
+    title: string;
+    bio: string;
+    role_id: string;
+    role: string;
+}
+export declare class SquadcastCommon {
+    static readonly MAX_DESCRIPTION_LENGTH = 1000;
+}
+/** SquadCast converter base */
+export declare abstract class SquadcastConverter extends Converter {
+    source: string;
+    /** Almost every SquadCast record have id property */
+    id(record: AirbyteRecord): any;
+    protected squadcastConfig(ctx: StreamContext): SquadcastConfig;
+    protected applicationMapping(ctx: StreamContext): ApplicationMapping;
+}
+export {};

package/lib/converters/squadcast/common.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SquadcastConverter = exports.SquadcastCommon = exports.IncidentSeverityCategory = exports.IncidentPriorityCategory = exports.IncidentStatusCategory = exports.IncidentEventTypeCategory = void 0;
+const converter_1 = require("../converter");
+var IncidentEventTypeCategory;
+(function (IncidentEventTypeCategory) {
+    IncidentEventTypeCategory["Created"] = "Created";
+    IncidentEventTypeCategory["Acknowledged"] = "Acknowledged";
+    IncidentEventTypeCategory["Resolved"] = "Resolved";
+    IncidentEventTypeCategory["Custom"] = "Custom";
+})(IncidentEventTypeCategory = exports.IncidentEventTypeCategory || (exports.IncidentEventTypeCategory = {}));
+var IncidentStatusCategory;
+(function (IncidentStatusCategory) {
+    IncidentStatusCategory["Identified"] = "Identified";
+    IncidentStatusCategory["Investigating"] = "Investigating";
+    IncidentStatusCategory["Monitoring"] = "Monitoring";
+    IncidentStatusCategory["Resolved"] = "Resolved";
+    IncidentStatusCategory["Custom"] = "Custom";
+})(IncidentStatusCategory = exports.IncidentStatusCategory || (exports.IncidentStatusCategory = {}));
+var IncidentPriorityCategory;
+(function (IncidentPriorityCategory) {
+    IncidentPriorityCategory["Critical"] = "Critical";
+    IncidentPriorityCategory["High"] = "High";
+    IncidentPriorityCategory["Medium"] = "Medium";
+    IncidentPriorityCategory["Low"] = "Low";
+    IncidentPriorityCategory["Custom"] = "Custom";
+})(IncidentPriorityCategory = exports.IncidentPriorityCategory || (exports.IncidentPriorityCategory = {}));
+var IncidentSeverityCategory;
+(function (IncidentSeverityCategory) {
+    IncidentSeverityCategory["Sev1"] = "Sev1";
+    IncidentSeverityCategory["Sev2"] = "Sev2";
+    IncidentSeverityCategory["Sev3"] = "Sev3";
+    IncidentSeverityCategory["Sev4"] = "Sev4";
+    IncidentSeverityCategory["Sev5"] = "Sev5";
+    IncidentSeverityCategory["Custom"] = "Custom";
+})(IncidentSeverityCategory = exports.IncidentSeverityCategory || (exports.IncidentSeverityCategory = {}));
+class SquadcastCommon {
+}
+exports.SquadcastCommon = SquadcastCommon;
+// Max length for free-form description text fields such as issue body
+SquadcastCommon.MAX_DESCRIPTION_LENGTH = 1000;
+/** SquadCast converter base */
+class SquadcastConverter extends converter_1.Converter {
+    constructor() {
+        super(...arguments);
+        this.source = 'SquadCast';
+    }
+    /** Almost every SquadCast record have id property */
+    id(record) {
+        var _a, _b;
+        return (_b = (_a = record === null || record === void 0 ? void 0 : record.record) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.id;
+    }
+    squadcastConfig(ctx) {
+        var _a, _b;
+        return (_b = (_a = ctx.config.source_specific_configs) === null || _a === void 0 ? void 0 : _a.squadcast) !== null && _b !== void 0 ? _b : {};
+    }
+    applicationMapping(ctx) {
+        var _a, _b;
+        return ((_b = (0, converter_1.parseObjectConfig)((_a = this.squadcastConfig(ctx)) === null || _a === void 0 ? void 0 : _a.application_mapping, 'Application Mapping')) !== null && _b !== void 0 ? _b : {});
+    }
+}
+exports.SquadcastConverter = SquadcastConverter;

package/lib/converters/squadcast/events.d.ts

@@ -0,0 +1,9 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { SquadcastConverter } from './common';
+export declare class Events extends SquadcastConverter {
+    id(record: AirbyteRecord): string;
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+    private toEventType;
+}

package/lib/converters/squadcast/events.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Events = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+class Events extends common_1.SquadcastConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'ims_IncidentEvent',
+        ];
+    }
+    id(record) {
+        var _a, _b;
+        return (_b = (_a = record === null || record === void 0 ? void 0 : record.record) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.alert_source_id;
+    }
+    async convert(record, ctx) {
+        var _a, _b, _c;
+        const source = this.streamName.source;
+        const event = record.record.data;
+        const status = (_a = event === null || event === void 0 ? void 0 : event.payload) === null || _a === void 0 ? void 0 : _a.status;
+        // Event ID can be undefined. It maybe because incident has one event
+        const DEFAULT_EVENT_ID = 1;
+        return [
+            {
+                model: 'ims_IncidentEvent',
+                record: {
+                    uid: (_c = (_b = event === null || event === void 0 ? void 0 : event.payload) === null || _b === void 0 ? void 0 : _b.event_id) !== null && _c !== void 0 ? _c : String(DEFAULT_EVENT_ID),
+                    type: status && this.toEventType(status),
+                    createdAt: faros_feeds_sdk_1.Utils.toDate(event.time_of_creation),
+                    detail: event.message,
+                    incident: { uid: event.incident_id, source },
+                },
+            },
+        ];
+    }
+    toEventType(status) {
+        const detail = status.toLowerCase();
+        switch (detail) {
+            case 'investigating':
+            case 'triggered':
+                return { category: common_1.IncidentEventTypeCategory.Created, detail };
+            case 'identified':
+            case 'acknowledged':
+                return { category: common_1.IncidentEventTypeCategory.Acknowledged, detail };
+            case 'resolved':
+                return { category: common_1.IncidentEventTypeCategory.Resolved, detail };
+            default:
+                return { category: common_1.IncidentEventTypeCategory.Custom, detail };
+        }
+    }
+}
+exports.Events = Events;

package/lib/converters/squadcast/incidents.d.ts

@@ -0,0 +1,10 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { SquadcastConverter } from './common';
+export declare class Incidents extends SquadcastConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+    private toPriority;
+    private toSeverity;
+    private toIncidentStatus;
+}

package/lib/converters/squadcast/incidents.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Incidents = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+class Incidents extends common_1.SquadcastConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'compute_Application',
+            'ims_Incident',
+            'ims_IncidentApplicationImpact',
+            'ims_Label',
+        ];
+    }
+    async convert(record, ctx) {
+        var _a, _b;
+        const source = this.streamName.source;
+        const incident = record.record.data;
+        const res = [];
+        const incidentRef = { uid: incident.id, source };
+        const createdAt = faros_feeds_sdk_1.Utils.toDate(incident.created_at);
+        const acknowledgedAt = faros_feeds_sdk_1.Utils.toDate(incident.acknowledged_at);
+        const resolvedAt = faros_feeds_sdk_1.Utils.toDate(incident.resolved_at);
+        let updatedAt = resolvedAt > acknowledgedAt ? resolvedAt : acknowledgedAt;
+        if (createdAt > updatedAt) {
+            updatedAt = createdAt;
+        }
+        const status = incident.status && this.toIncidentStatus(incident.status);
+        /** SquadCast doesn't have incident severity and priority, take "severity" and "priority" from tags */
+        let priority;
+        let severity;
+        Object.entries(incident.tags || {}).forEach(([name, tag]) => {
+            if (tag.value) {
+                if (name === 'severity') {
+                    severity = this.toSeverity(tag.value);
+                }
+                if (name === 'priority') {
+                    priority = this.toPriority(tag.value);
+                }
+            }
+            const label = { name };
+            res.push({
+                model: 'ims_Label',
+                record: label,
+            });
+            res.push({
+                model: 'ims_IncidentTag',
+                record: {
+                    incident: incidentRef,
+                    label,
+                },
+            });
+        });
+        res.push({
+            model: 'ims_Incident',
+            record: {
+                ...incidentRef,
+                title: incident.title,
+                description: (_a = incident.description) === null || _a === void 0 ? void 0 : _a.substring(0, common_1.SquadcastCommon.MAX_DESCRIPTION_LENGTH),
+                createdAt,
+                updatedAt,
+                acknowledgedAt,
+                resolvedAt,
+                priority,
+                severity,
+                status,
+            },
+        });
+        if (incident.service) {
+            const applicationMapping = this.applicationMapping(ctx);
+            let application = { name: incident.service, platform: '' };
+            if (incident.service in applicationMapping &&
+                applicationMapping[incident.service].name) {
+                const mappedApp = applicationMapping[incident.service];
+                application = {
+                    name: mappedApp.name,
+                    platform: (_b = mappedApp.platform) !== null && _b !== void 0 ? _b : application.platform,
+                };
+            }
+            res.push({
+                model: 'ims_IncidentApplicationImpact',
+                record: {
+                    incident: incidentRef,
+                    application,
+                },
+            });
+        }
+        return res;
+    }
+    toPriority(priority) {
+        const detail = priority.toLowerCase();
+        switch (detail) {
+            case 'critical':
+                return { category: common_1.IncidentPriorityCategory.Critical, detail };
+            case 'high':
+                return { category: common_1.IncidentPriorityCategory.High, detail };
+            case 'medium':
+                return { category: common_1.IncidentPriorityCategory.Medium, detail };
+            case 'low':
+                return { category: common_1.IncidentPriorityCategory.Low, detail };
+            default:
+                return { category: common_1.IncidentPriorityCategory.Custom, detail };
+        }
+    }
+    toSeverity(severity) {
+        const detail = severity.toLowerCase();
+        switch (detail) {
+            case 'sev1':
+                return { category: common_1.IncidentSeverityCategory.Sev1, detail };
+            case 'sev2':
+                return { category: common_1.IncidentSeverityCategory.Sev2, detail };
+            case 'sev3':
+                return { category: common_1.IncidentSeverityCategory.Sev3, detail };
+            case 'sev4':
+                return { category: common_1.IncidentSeverityCategory.Sev4, detail };
+            case 'sev5':
+                return { category: common_1.IncidentSeverityCategory.Sev5, detail };
+            default:
+                return { category: common_1.IncidentSeverityCategory.Custom, detail };
+        }
+    }
+    toIncidentStatus(incidentState) {
+        const detail = incidentState.toLowerCase();
+        switch (incidentState) {
+            case 'investigating':
+            case 'triggered':
+                return { category: common_1.IncidentStatusCategory.Investigating, detail };
+            case 'identified':
+            case 'acknowledged':
+                return { category: common_1.IncidentStatusCategory.Identified, detail };
+            case 'monitoring':
+                return { category: common_1.IncidentStatusCategory.Monitoring, detail };
+            case 'resolved':
+                return { category: common_1.IncidentStatusCategory.Resolved, detail };
+            default:
+                return { category: common_1.IncidentStatusCategory.Custom, detail };
+        }
+    }
+}
+exports.Incidents = Incidents;

package/lib/converters/squadcast/services.d.ts

@@ -0,0 +1,7 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { SquadcastConverter } from './common';
+export declare class Services extends SquadcastConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+}

package/lib/converters/squadcast/services.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = void 0;
+const common_1 = require("./common");
+class Services extends common_1.SquadcastConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'compute_Application',
+        ];
+    }
+    async convert(record, ctx) {
+        var _a;
+        const service = record.record.data;
+        const applicationMapping = this.applicationMapping(ctx);
+        let application = { name: service.name, platform: '' };
+        if (service.name in applicationMapping &&
+            applicationMapping[service.name].name) {
+            const mappedApp = applicationMapping[service.name];
+            application = {
+                name: mappedApp.name,
+                platform: (_a = mappedApp.platform) !== null && _a !== void 0 ? _a : application.platform,
+            };
+        }
+        return [{ model: 'compute_Application', record: application }];
+    }
+}
+exports.Services = Services;

package/lib/converters/squadcast/users.d.ts

@@ -0,0 +1,7 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { SquadcastConverter } from './common';
+export declare class Users extends SquadcastConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+}

package/lib/converters/squadcast/users.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Users = void 0;
+const common_1 = require("./common");
+class Users extends common_1.SquadcastConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = ['ims_User'];
+    }
+    async convert(record, ctx) {
+        const source = this.streamName.source;
+        const user = record.record.data;
+        const username = `${user.first_name} ${user.last_name}`;
+        return [
+            {
+                model: 'ims_User',
+                record: {
+                    uid: user.id,
+                    email: user.email,
+                    name: username,
+                    source,
+                },
+            },
+        ];
+    }
+}
+exports.Users = Users;

package/lib/converters/statuspage/common.d.ts

@@ -0,0 +1,93 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { Converter, StreamContext } from '../converter';
+declare type ApplicationMapping = Record<string, {
+    name: string;
+    platform?: string;
+}>;
+interface StatusPageConfig {
+    application_mapping?: ApplicationMapping;
+}
+export interface Component {
+    created_at: string;
+    description: string | null;
+    group: boolean;
+    group_id: string | null;
+    id: string;
+    name: string;
+    only_show_if_degraded: boolean;
+    page_id: string;
+    position: number;
+    showcase: boolean;
+    start_date: string | null;
+    status: string;
+    updated_at: string;
+}
+export declare enum ComponentStatus {
+    degraded_performance = "degraded_performance",
+    major_outage = "major_outage",
+    operational = "operational",
+    partial_outage = "partial_outage",
+    under_maintenance = "under_maintenance"
+}
+export declare enum IncidentEventTypeCategory {
+    Created = "Created",
+    Acknowledged = "Acknowledged",
+    Resolved = "Resolved",
+    Custom = "Custom"
+}
+export interface IncidentEventType {
+    category: IncidentEventTypeCategory;
+    detail: string;
+}
+export declare enum StatuspageIncidentImpact {
+    Critical = "critical",
+    Major = "major",
+    Minor = "minor",
+    None = "none"
+}
+export declare enum StatuspageIncidentStatus {
+    Identified = "identified",
+    Investigating = "investigating",
+    Monitoring = "monitoring",
+    Postmortem = "postmortem",
+    Resolved = "resolved"
+}
+export declare enum IncidentStatusCategory {
+    Identified = "Identified",
+    Investigating = "Investigating",
+    Monitoring = "Monitoring",
+    Resolved = "Resolved",
+    Custom = "Custom"
+}
+export interface IncidentPriority {
+    category: IncidentPriorityCategory;
+    detail: string;
+}
+export declare enum IncidentPriorityCategory {
+    Critical = "Critical",
+    High = "High",
+    Medium = "Medium",
+    Low = "Low",
+    Custom = "Custom"
+}
+export declare enum IncidentSeverityCategory {
+    Sev1 = "Sev1",
+    Sev2 = "Sev2",
+    Sev3 = "Sev3",
+    Sev4 = "Sev4",
+    Sev5 = "Sev5",
+    Custom = "Custom"
+}
+export interface IncidentSeverity {
+    category: IncidentSeverityCategory;
+    detail: string;
+}
+/** StatusPage converter base */
+export declare abstract class StatusPageConverter extends Converter {
+    source: string;
+    /** Every StatusPage record have id property */
+    id(record: AirbyteRecord): any;
+    protected statuspageConfig(ctx: StreamContext): StatusPageConfig;
+    protected applicationMapping(ctx: StreamContext): ApplicationMapping;
+}
+export {};