ℹAbout Str:::lab Studio

Str:::lab Studio is a browser-based SQL Studio that connects to any Flink SQL Gateway. It provides a complete development, monitoring, and administration experience — without the overhead of a full platform deployment. Works with local Docker, Kubernetes, and any self-hosted Flink cluster.

⚡Quickstart

git clone https://github.com/coded-streams/strlabstudio
cd strlabstudio
docker compose up -d
open http://localhost:3030

python3 -m http.server 8080
# Open studio/index.html — use Direct Gateway mode

helm repo add strlabstudio https://coded-streams.github.io/strlabstudio-operator/charts
helm install strlabstudio-operator strlabstudio/strlabstudio-operator \
  --namespace flinksql-system --create-namespace

kubectl apply -f - <<EOF
apiVersion: codedstreams.io/v1alpha1
kind: StrlabStudio
metadata:
  name: my-studio
  namespace: flink
spec:
  gateway:
    host: flink-sql-gateway
    port: 8083
  jobmanager:
    host: flink-jobmanager
    port: 8081
EOF

Connection Modes

🏗Architecture

Str:::lab Studio is a static HTML file served by nginx. All SQL execution happens via the Flink SQL Gateway REST API. The browser manages all session state client-side.

State & Session Management

✦All Features

Editor

Sessions

Job Graph

Performance Monitoring

Reports

Themes & UX

🛡Admin Session

The Admin Session mode provides a privileged view of the entire Flink cluster — across all users and sessions. Access it from the connect screen by selecting the Admin mode and entering the admin passcode.

Capabilities

• Full cluster job visibility — see ALL jobs running on the cluster, not just the ones submitted in this session.
• Per-session activity — the Sessions Activity modal shows each registered session's submitted jobs, query count, and running job status.
• Cross-session job attribution — jobs are tagged with their session name (visible in the Job Graph select dropdown).
• Cancel any job — admins can cancel any running job on the cluster, with a confirmation dialog.
• Admin-grade PDF reports — choose between a Technical Report (engineering detail) or Business/Management Report (self-explanatory metrics). Both carry the admin's name and session ID.
• Change admin passcode — click the 🛡 ADMIN badge in the topbar to open Admin Settings where you can update your display name and change the passcode.

Session isolation model

💡Tips & Concepts Modal

On first connection, Str:::lab Studio displays a paginated Tips & Concepts modal — inspired by JetBrains "Tip of the Day". It covers 16 topics across 6 categories:

Users can navigate tips with Prev/Next buttons or click category tags to jump directly to that section. A "Don't show on startup" checkbox suppresses the modal on future connections. The modal can be reopened at any time via the topbar — the ℹ About button also includes a tips launcher.

✂Snippets Library

30+ built-in SQL templates accessible from the toolbar. Click any snippet to insert into the active editor tab.

🔌Connector JARs

.\scripts\download-connectors.ps1
# Auto-detects Flink version from running container.
# Override: .\scripts\download-connectors.ps1 -FlinkVersion 1.19.1

./scripts/download-connectors.sh
# Override: ./scripts/download-connectors.sh --flink-version 1.19.1

FROM flink:1.19.1-scala_2.12-java11
USER root
RUN apt-get update && apt-get install -y libgomp1 && rm -rf /var/lib/apt/lists/*
COPY ./connectors/*.jar /opt/flink/lib/
USER flink

🔀Full Pipeline Demo

A complete multi-stage streaming pipeline built entirely in Str:::lab Studio: datagen source → Kafka → enrichment with branching → windowed aggregation → live preview.

SET 'execution.runtime-mode' = 'streaming';
SET 'parallelism.default' = '1';
SET 'pipeline.operator-chaining' = 'false';
SET 'execution.checkpointing.interval' = '10000';

CREATE TEMPORARY TABLE trade_gen (
  trade_id STRING, symbol STRING, side STRING,
  quantity DOUBLE, price DOUBLE, exchange STRING,
  event_time TIMESTAMP(3),
  WATERMARK FOR event_time AS event_time - INTERVAL '5' SECOND
) WITH ('connector' = 'datagen', 'rows-per-second' = '5');

INSERT INTO trade_events_kafka
SELECT trade_id, symbol, side, quantity, price, exchange, event_time
FROM trade_gen;

EXECUTE STATEMENT SET BEGIN
INSERT INTO enriched_trades_kafka
SELECT trade_id, symbol, side,
  ROUND(quantity * price, 2) AS trade_value,
  CASE WHEN quantity * price >= 100000 THEN 'CRITICAL'
       WHEN quantity * price >=  10000 THEN 'HIGH'
       ELSE 'LOW' END AS risk_level, event_time
FROM trade_events_source;

INSERT INTO branch_alerts_sink
SELECT trade_id, symbol, ROUND(quantity * price, 2) AS trade_value, event_time
FROM trade_events_source WHERE quantity * price >= 10000;
END;

INSERT INTO trade_summary_kafka
SELECT window_start, window_end, symbol, side,
  COUNT(*) AS trade_count,
  ROUND(SUM(quantity * price), 2) AS total_volume
FROM TABLE(TUMBLE(TABLE enriched_trades_source,
  DESCRIPTOR(event_time), INTERVAL '10' SECOND))
GROUP BY window_start, window_end, symbol, side;

SELECT trade_id, symbol, side, trade_value, risk_level, event_time
FROM enriched_trades_view;

☸️Str:::lab Studio Kube Operator

The Str:::lab Studio Kube Operator manages Str:::lab Studio deployments as first-class Kubernetes CRDs. Deploy and lifecycle-manage Studio instances with a single kubectl apply. Built with Kopf (Python).

Repository: github.com/coded-streams/strlabstudio-operator

CRD Reference — StrlabStudio

Short name: kubectl get fss  ·  Group: codedstreams.io/v1alpha1

helm repo add strlabstudio https://coded-streams.github.io/strlabstudio-operator/charts
helm repo update
helm install strlabstudio-operator strlabstudio/strlabstudio-operator \
  --namespace flinksql-system --create-namespace

kubectl get pods -n flinksql-system
kubectl get crd strlabstudio.codedstreams.io

apiVersion: codedstreams.io/v1alpha1
kind: StrlabStudio
metadata:
  name: dev-studio
  namespace: flink
spec:
  gateway:
    host: flink-sql-gateway
    port: 8083
  jobmanager:
    host: flink-jobmanager
    port: 8081

apiVersion: codedstreams.io/v1alpha1
kind: StrlabStudio
metadata:
  name: dev-studio
  namespace: flink
spec:
  gateway:
    host: flink-sql-gateway
  jobmanager:
    host: flink-jobmanager
  service:
    type: NodePort
    nodePort: 30303

apiVersion: codedstreams.io/v1alpha1
kind: StrlabStudio
metadata:
  name: prod-studio
  namespace: flink
spec:
  image: codedstreams/strlabstudio:v1.0.22
  replicas: 2
  gateway:
    host: flink-sql-gateway
    port: 8083
  jobmanager:
    host: flink-jobmanager
    port: 8081
  service:
    type: LoadBalancer
    port: 80
  resources:
    requests: {cpu: "100m", memory: "128Mi"}
    limits:   {cpu: "500m", memory: "256Mi"}

🚀Deployment Options

docker compose up -d

python3 -m http.server 8080

helm install strlabstudio-operator \
  strlabstudio/strlabstudio-operator

⬡Project Manager

The Project Manager lets you save, load, run, and organise your Str:::lab work as named projects. Access it from the topbar via the ⬡ Projects button. Projects are stored in browser localStorage and can be exported and imported as JSON files.

What a project stores

Three tabs

Workflow

1. Write your SQL across tabs. Run SET statements to configure the session.
2. Open ⬡ Projects → ＋ New Project. Name it, tick snapshot tabs + config, click ⬡ Create Project.
3. The project appears in the list with an ACTIVE badge. The topbar shows the project name.
4. Continue working. Click 💾 Save Current State (modal footer) to update the active project.
5. To restore: open ⬡ Projects → Load on any project. This replaces the editor tabs.
6. To share: click ⬇ on any project row to download a .json file. Import on any other Studio instance.

⨍UDF Manager

The UDF Manager is a dedicated feature for the complete User-Defined Function lifecycle — from building to uploading to registering to using — without leaving Str:::lab Studio. Access it from the topbar via the ⨍ UDFs button. It has five tabs.

What are UDFs?

UDFs extend Flink SQL with custom logic that built-in functions cannot express. Flink supports four types:

📚 Library Tab — Browse & Quick-Insert

Click ⟳ Refresh to run SHOW FUNCTIONS and SHOW USER FUNCTIONS against the active session. Results split into User-Defined (blue) and Built-in. Use the search bar and type filter. Click any function name to insert it at the cursor in the editor with parentheses ready.

⬆ Upload JAR Tab — Deploy Directly to the Cluster

Str:::lab Studio can upload a JAR file directly to the Flink JobManager via the same REST endpoint that the Flink Web UI uses: POST /jars/upload. No SSH, no manual file copying. Once uploaded, the JAR is available to all TaskManagers immediately.

1. Drag-and-drop your .jar file onto the drop zone, or click to browse.
2. Click ⬆ Upload JAR to Flink Cluster — a live progress bar tracks the upload.
3. The JARs on cluster list refreshes automatically. Click Use → on any entry to pre-fill the Register tab.
4. Optionally delete JARs from the cluster using the Delete button on each row.

⬡ Maven / Gradle Tab — Dependency & Build Config

Maven and Gradle resolve your UDF's dependencies and package everything into a single deployable JAR. This tab generates the correct build configuration and commands so you never have to guess at dependency scopes or version strings.

<dependencies>

    <!--
      Flink APIs — scope="provided"
      These JARs are already on the cluster. DO NOT bundle them.
      "provided" means: compile against them, but exclude from the output JAR.
    -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-table-api-java</artifactId>
        <version>${flink.version}</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-table-common</artifactId>
        <version>${flink.version}</version>
        <scope>provided</scope>
    </dependency>

    <!-- Your own third-party deps — these ARE bundled (default scope) -->
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>32.1.3-jre</version>
    </dependency>

</dependencies>

<!-- Maven Shade Plugin: creates the shaded (fat) JAR -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.5.1</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals><goal>shade</goal></goals>
            <configuration>
                <shadedArtifactAttached>true</shadedArtifactAttached>
                <shadedClassifierName>shaded</shadedClassifierName>
            </configuration>
        </execution>
    </executions>
</plugin>

<!-- Build command: -->
<!-- mvn clean package -DskipTests -->
<!-- Output: target/my-udfs-1.0.0-shaded.jar -->

plugins {
    id 'java'
    // Shadow plugin: creates the fat JAR
    id 'com.github.johnrengelman.shadow' version '8.1.1'
}

dependencies {
    /*
     * compileOnly = Maven "provided"
     * These JARs are already on the Flink cluster.
     * DO NOT use 'implementation' for Flink APIs — it bundles them
     * into your JAR and causes ClassLoader conflicts.
     */
    compileOnly "org.apache.flink:flink-table-api-java:${flinkVersion}"
    compileOnly "org.apache.flink:flink-table-common:${flinkVersion}"

    // Your own third-party deps — use 'implementation' (bundled)
    implementation 'com.google.guava:guava:32.1.3-jre'
}

shadowJar {
    archiveClassifier = 'shaded'
    mergeServiceFiles()
    exclude 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA'
}

// Build command:
// ./gradlew shadowJar
// Output: build/libs/my-udfs-1.0.0-shaded.jar

＋ Register Tab — Activate a JAR Function

After uploading a JAR (via the Upload JAR tab or manually), use this tab to write the CREATE FUNCTION statement that makes the class available as a SQL function.

1. Enter the function name (what you will call in SQL).
2. Enter the fully-qualified class path (e.g. com.yourcompany.udf.MaskEmail).
3. Choose Language: Java, Scala, or Python.
4. Choose Scope: Temporary (session only), Temporary System (all catalogs), or Permanent (catalog-persisted).
5. Click ⚡ Execute Registration to send the CREATE FUNCTION to the gateway, or Insert into Editor to review first.

✎ SQL UDF Tab — No JAR, No Java

Write a UDF entirely in Flink SQL. No JAR, no build step. Supported in Flink 1.17+.

CREATE TEMPORARY FUNCTION classify_risk(score DOUBLE)
RETURNS STRING LANGUAGE SQL AS $$
  CASE
    WHEN score >= 0.8 THEN 'CRITICAL'
    WHEN score >= 0.5 THEN 'WARNING'
    WHEN score >= 0.2 THEN 'LOW'
    ELSE 'NORMAL'
  END
$$;

SELECT event_id, score, classify_risk(score) AS tier
FROM risk_events;

CREATE TEMPORARY FUNCTION fmt_bytes(b BIGINT)
RETURNS STRING LANGUAGE SQL AS $$
  CASE
    WHEN b >= 1073741824 THEN CONCAT(CAST(b/1073741824 AS STRING), ' GB')
    WHEN b >= 1048576    THEN CONCAT(CAST(b/1048576 AS STRING),    ' MB')
    WHEN b >= 1024       THEN CONCAT(CAST(b/1024 AS STRING),       ' KB')
    ELSE CONCAT(CAST(b AS STRING), ' B')
  END
$$;

SELECT node_id, fmt_bytes(bytes_transferred) AS readable_size
FROM network_events;

CREATE TEMPORARY FUNCTION safe_region(region STRING, fallback STRING)
RETURNS STRING LANGUAGE SQL AS $$
  CASE
    WHEN region IS NULL OR TRIM(region) = '' THEN fallback
    ELSE UPPER(TRIM(region))
  END
$$;

SELECT event_id, safe_region(region, 'UNKNOWN') AS normalised_region
FROM events;

⊞ Templates Tab — Production-Ready Examples

Complete JAR UDF Workflow

Demo — Fraud Detection Pipeline with SQL UDFs

The UDF Manager ships with a complete demo SQL file: udf-fraud-detection-demo.sql. It demonstrates all five tabs using a real-time payment fraud detection scenario — 50 transactions per second, 7 SQL UDFs, 4 running Flink jobs, 5 Kafka topics.

-- Register all 7 SQL UDFs — no JAR, no Java required

CREATE TEMPORARY FUNCTION classify_risk(score DOUBLE)
RETURNS STRING LANGUAGE SQL AS $$
  CASE WHEN score >= 0.80 THEN 'CRITICAL'
       WHEN score >= 0.55 THEN 'HIGH'
       WHEN score >= 0.30 THEN 'MEDIUM'
       ELSE 'LOW' END $$;

CREATE TEMPORARY FUNCTION mask_card(card STRING)
RETURNS STRING LANGUAGE SQL AS $$
  CASE WHEN card IS NULL OR CHAR_LENGTH(card) < 8 THEN '****-****-****-****'
       ELSE CONCAT(SUBSTRING(card,1,4),'-****-****-',
                   SUBSTRING(card,CHAR_LENGTH(card)-3,4)) END $$;

CREATE TEMPORARY FUNCTION mask_email(email STRING)
RETURNS STRING LANGUAGE SQL AS $$
  CASE WHEN email IS NULL OR POSITION('@' IN email) <= 2 THEN '**@***.***'
       ELSE CONCAT(SUBSTRING(email,1,2),'***',
                   SUBSTRING(email,POSITION('@' IN email))) END $$;

CREATE TEMPORARY FUNCTION amount_band(amt DOUBLE)
RETURNS STRING LANGUAGE SQL AS $$
  CASE WHEN amt >= 10000 THEN 'WHALE'
       WHEN amt >= 2500  THEN 'LARGE'
       WHEN amt >= 500   THEN 'MEDIUM'
       WHEN amt >= 50    THEN 'SMALL'
       ELSE 'MICRO' END $$;

-- Verify all 7 are registered:
SHOW USER FUNCTIONS;

-- Pipeline 1: Cleanse raw events — mask PII, normalise fields
-- UDFs: mask_card(), mask_email(), normalize_currency()
INSERT INTO cleansed_sink
SELECT
    txn_id,
    customer_id,
    mask_card(card_number)           AS card_masked,
    mask_email(email)                AS email_masked,
    ROUND(amount_usd, 2)             AS amount_usd,
    normalize_currency(currency_raw) AS currency,
    merchant_id,
    CASE merchant_country
        WHEN 0 THEN 'US'  WHEN 1 THEN 'EU'
        WHEN 2 THEN 'UK'  WHEN 3 THEN 'APAC'
        WHEN 4 THEN 'LATAM' ELSE 'MEA'
    END                              AS merchant_country,
    CASE channel_raw
        WHEN 0 THEN 'ONLINE' WHEN 1 THEN 'MOBILE'
        WHEN 2 THEN 'POS'    ELSE 'ATM'
    END                              AS channel,
    ROUND(risk_score, 4)             AS risk_score,
    latency_ms,
    event_ts
FROM raw_transactions;

-- Pipeline 3: TUMBLE(1 min) fraud KPI aggregation
-- UDFs used inside COUNT(CASE ...) aggregations
INSERT INTO fraud_kpi_sink
SELECT
    TUMBLE_START(event_ts, INTERVAL '1' MINUTE)  AS window_start,
    TUMBLE_END(event_ts,   INTERVAL '1' MINUTE)  AS window_end,
    merchant_country,
    channel,
    COUNT(*)                                      AS total_txns,
    ROUND(SUM(amount_usd), 2)                     AS total_volume_usd,
    ROUND(AVG(risk_score), 4)                     AS avg_risk_score,
    -- UDF inside aggregation: count CRITICAL transactions per window
    COUNT(CASE WHEN classify_risk(risk_score) = 'CRITICAL' THEN 1 END) AS critical_count,
    COUNT(CASE WHEN classify_risk(risk_score) = 'HIGH'     THEN 1 END) AS high_count,
    -- UDF inside aggregation: count whale transactions per window
    COUNT(CASE WHEN amount_band(amount_usd) = 'WHALE' THEN 1 END)     AS whale_count,
    ROUND(
      CAST(COUNT(CASE WHEN classify_risk(risk_score) IN ('CRITICAL','HIGH') THEN 1 END) AS DOUBLE)
      / NULLIF(COUNT(*), 0) * 100.0
    , 2)                                          AS fraud_rate_pct
FROM cleansed_source
GROUP BY TUMBLE(event_ts, INTERVAL '1' MINUTE), merchant_country, channel;

-- Tab 7: All 7 UDFs in a single live SELECT
-- Enable "✦ Colour Describe" — risk_tier and sla_tier drive row coloring:
--   🔴 Red    = CRITICAL  🟡 Yellow = HIGH/MEDIUM  🟢 Green = LOW
SELECT
    txn_id,
    customer_id,
    card_masked,
    ROUND(amount_usd, 2)                AS amount_usd,
    currency,
    merchant_country,
    channel,
    ROUND(risk_score, 3)                AS risk_score,
    classify_risk(risk_score)           AS risk_tier,
    amount_band(amount_usd)             AS amount_band,
    velocity_flag(latency_ms)           AS velocity,
    sla_tier(latency_ms, risk_score)    AS sla_tier,
    latency_ms,
    event_ts
FROM cleansed_source;

📝Changelog