Honeycomb

Log in to your Honeycomb account at app.honeycomb.io. In the left sidebar, click on your team name to open the team settings, then navigate to 'Datasets'. Click 'New Dataset' and give it a name that reflects your app — for example, `flutterflow-app-events` or just your app's name. The dataset name will appear in the Honeycomb UI when you query your events. Next, create an ingest API key. Go to Team Settings → API Keys → Create API Key. Give the key a descriptive name like 'FlutterFlow Production Ingest'. Make sure the key has the 'Send Events' permission enabled. Copy the key value immediately after creation — Honeycomb shows the full key value only once at creation time. Store it somewhere secure for the next step. You'll also need the dataset name exactly as you created it — it goes in the API URL path (`/1/batch/{dataset}`). The dataset name is case-sensitive. Note on the API key: Honeycomb has two types of keys — 'Classic' API keys (which need an explicit dataset name in the URL) and newer 'Environment & Services' keys (which use the `X-Honeycomb-Dataset` header instead). The difference affects how you structure the Cloud Function proxy request. If you're on a new Honeycomb account, you're likely using Environment & Services keys. The code example in Step 2 covers the Classic approach with the dataset name in the URL — adjust if your team uses the newer format.

The Cloud Function is the critical piece that keeps the Honeycomb ingest key off your device. It accepts batched event arrays from your FlutterFlow app, adds the `X-Honeycomb-Team` header server-side, and forwards the request to Honeycomb's batch events endpoint. In your Firebase Cloud Functions project (in the `functions/` directory alongside your Firebase project), install the `axios` package for HTTP requests. Create the Cloud Function shown in the code block below. Set the Honeycomb API key as a Firebase environment variable using `firebase functions:config:set honeycomb.api_key="your-key-here" honeycomb.dataset="your-dataset-name"` — this keeps it out of your source code entirely. Deploy the function with `firebase deploy --only functions`. Copy the deployed function URL — it will look like `https://us-central1-your-project.cloudfunctions.net/sendHoneycombEvents`. Test the Cloud Function directly before setting up FlutterFlow. Using curl or Postman, POST a simple event array to the function URL. Verify in your Honeycomb dataset that the test event appears within a few seconds of sending. If it does, the proxy is working correctly and you're ready to configure FlutterFlow. The Cloud Function accepts an array of event objects in the Honeycomb batch format: each object has a `time` field (ISO 8601 or Unix timestamp) and a `data` object with your custom key-value pairs. You can include any fields you want in `data` — Honeycomb's schema-on-read approach means you don't need to pre-define columns.

1// Firebase Cloud Function: Honeycomb Events Proxy
2// functions/index.js
3const functions = require('firebase-functions');
4const axios = require('axios');
5
6// Set env config: firebase functions:config:set
7//   honeycomb.api_key="your-ingest-key"
8//   honeycomb.dataset="your-dataset-name"
9const HONEYCOMB_API_KEY = process.env.HONEYCOMB_API_KEY ||
10  (functions.config().honeycomb && functions.config().honeycomb.api_key);
11const HONEYCOMB_DATASET = process.env.HONEYCOMB_DATASET ||
12  (functions.config().honeycomb && functions.config().honeycomb.dataset);
13
14exports.sendHoneycombEvents = functions.https.onRequest(async (req, res) => {
15  res.set('Access-Control-Allow-Origin', '*');
16  if (req.method === 'OPTIONS') {
17    res.set('Access-Control-Allow-Methods', 'POST');
18    res.set('Access-Control-Allow-Headers', 'Content-Type');
19    return res.status(204).send('');
20  }
21
22  if (req.method !== 'POST') {
23    return res.status(405).json({ error: 'Method not allowed' });
24  }
25
26  const events = req.body;
27  if (!Array.isArray(events) || events.length === 0) {
28    return res.status(400).json({ error: 'Request body must be a non-empty array of events' });
29  }
30
31  // Add a timestamp to any events missing one
32  const now = new Date().toISOString();
33  const batch = events.map(event => ({
34    time: event.time || now,
35    data: event.data || event
36  }));
37
38  try {
39    const response = await axios.post(
40      `https://api.honeycomb.io/1/batch/${encodeURIComponent(HONEYCOMB_DATASET)}`,
41      batch,
42      {
43        headers: {
44          'X-Honeycomb-Team': HONEYCOMB_API_KEY,
45          'Content-Type': 'application/json'
46        }
47      }
48    );
49    return res.json({ success: true, results: response.data });
50  } catch (err) {
51    console.error('Honeycomb API error:', err.response?.data || err.message);
52    return res.status(502).json({ error: err.message });
53  }
54});

With the Cloud Function proxy deployed and verified, set up the FlutterFlow side to call it. Click 'API Calls' in the left navigation panel (the plug icon), then click '+ Add' and choose 'Create API Group'. Name it 'HoneycombProxy'. Set the Base URL to your deployed Cloud Function URL (for example, `https://us-central1-your-project.cloudfunctions.net`). Leave authentication as 'No Auth' — security is handled inside the Cloud Function. Click '+ Add API Call' within the group. Name it 'BatchEvents'. Set the method to POST. Set the endpoint to `/sendHoneycombEvents` (matching your function name). In the Body section, set the content type to JSON and add a body variable named 'events' of type JSON. This variable will hold your array of event objects. In the Response & Test tab, paste a sample successful response from your earlier test: `{"success": true, "results": [{"status": 202}]}` Click 'Generate JSON Paths' if you want to check the success field. Then test the API Call by entering a sample events array in the variable field: `[{"data": {"event_type": "test", "source": "flutterflow"}}]` Click 'Test API Call' and confirm you get a 200 response with success: true. Check Honeycomb to confirm the test event arrived. Now add this API Call to your Action Flows. For example, to fire an event when a button is tapped: select the button → Actions panel → + Add Action → Backend/API Calls → API Call (select BatchEvents) → set the events variable to a JSON array constructed from your page/widget state values. You can use FlutterFlow's JSON builder to construct the event object dynamically with field values from your app state.

1// Sample events array to test in FlutterFlow API Call body
2// Paste into the 'events' variable field in the Test tab
3[
4  {
5    "time": "2026-07-09T12:00:00Z",
6    "data": {
7      "event_type": "button_tap",
8      "button_name": "complete_purchase",
9      "user_id": "user_12345",
10      "product_id": "prod_abc",
11      "duration_ms": 342,
12      "app_version": "1.2.0",
13      "platform": "android"
14    }
15  }
16]

Sending a separate HTTP request to the Cloud Function for every user action is inefficient on mobile — it generates many short-lived network requests and can quickly consume your Honeycomb event quota on high-traffic actions. A better pattern is to queue events on the device and flush them in batches. For simple batching without custom code: use FlutterFlow's App State (left nav → App State → + Add Field) to maintain a list variable called `pendingHoneycombEvents`. Append event objects to this list using Update App State actions. On screen navigation or after collecting 10+ events, fire the BatchEvents API Call with the entire list, then clear the list. This is achievable with FlutterFlow's built-in state and action system, no custom code required. For full OpenTelemetry distributed tracing (the most powerful Honeycomb use case), the path requires a Custom Action. Go to left nav → Custom Code → + Add → Action. Name it 'SendOTLPTrace'. In the Dependencies field, add an OpenTelemetry Dart package that supports OTLP export — search pub.dev for `opentelemetry` packages compatible with Flutter. The Custom Action initializes an OTLP trace exporter pointed at your Cloud Function's OTLP endpoint (you'd need to add OTLP support to the proxy, or use Honeycomb's OTLP endpoint directly if you're comfortable with the key exposure trade-off during development). Important constraints on the Custom Action path: - Custom Actions don't run in FlutterFlow's web Run preview — test on a real device only. - For production, the OTLP exporter should point at a Cloud Function proxy, not directly at `api.honeycomb.io`, so the `X-Honeycomb-Team` header stays server-side. - High-frequency per-tap OTLP spans can quickly exhaust free tier event budgets — sample aggressively (trace 1 in 100 sessions, not every action). For most FlutterFlow apps, the simple batch Events API Call approach in Steps 2-3 gives excellent observability without needing OTLP. Reserve the OTLP Custom Action for cases where you need trace IDs that correlate mobile spans with backend spans in a distributed tracing setup.

1// FlutterFlow Custom Action: Send queued events to Honeycomb proxy
2// Dart — for batching events stored in App State
3// Arguments:
4//   events: List<dynamic> (list of event JSON objects from App State)
5//   proxyUrl: String (your Cloud Function URL)
6// Return type: bool
7import 'dart:convert';
8import 'package:http/http.dart' as http;
9
10Future<bool> sendHoneycombBatch(
11  List<dynamic> events,
12  String proxyUrl,
13) async {
14  if (events.isEmpty) return true;
15
16  try {
17    final response = await http.post(
18      Uri.parse('$proxyUrl/sendHoneycombEvents'),
19      headers: {'Content-Type': 'application/json'},
20      body: jsonEncode(events),
21    );
22
23    if (response.statusCode == 200) {
24      return true;
25    } else {
26      debugPrint('Honeycomb proxy error: ${response.statusCode} ${response.body}');
27      return false;
28    }
29  } catch (e) {
30    debugPrint('Honeycomb send error: $e');
31    return false;
32  }
33}