Live: Telegraf input modifiers (#32982)

pkg/services/live/managed.go

@@ -87,30 +87,41 @@ func (s *ManagedStream) ListChannels(prefix string) []util.DynMap {
 }
 
 // Push sends frame to the stream and saves it for later retrieval by subscribers.
-func (s *ManagedStream) Push(path string, frame *data.Frame) error {
+func (s *ManagedStream) Push(path string, frame *data.Frame, stableSchema bool) error {
 	// Keep schema + data for last packet.
 	frameJSON, err := data.FrameToJSON(frame, true, true)
 	if err != nil {
-		logger.Error("Error marshaling Frame to Schema", "error", err)
+		logger.Error("Error marshaling frame with Schema", "error", err)
 		return err
 	}
 
-	// Locks until we totally finish?
-	s.mu.Lock()
-	defer s.mu.Unlock()
+	if stableSchema {
+		// If schema is stable we can safely cache it, and only send values if
+		// stream already has schema cached.
+		s.mu.Lock()
+		_, exists := s.last[path]
+		s.last[path] = frameJSON
+		s.mu.Unlock()
 
-	_, exists := s.last[path]
-	s.last[path] = frameJSON
-
-	// When the packet already exits, only send the data.
-	if exists {
-		frameJSON, err = data.FrameToJSON(frame, false, true)
-		if err != nil {
-			logger.Error("Error marshaling Frame to JSON", "error", err)
-			return err
+		// When the packet already exits, only send the data.
+		// TODO: maybe a good idea would be MarshalJSON function of
+		// frame to keep Schema JSON and Values JSON in frame object
+		// to avoid encoding twice.
+		if exists {
+			frameJSON, err = data.FrameToJSON(frame, false, true)
+			if err != nil {
+				logger.Error("Error marshaling Frame to JSON", "error", err)
+				return err
+			}
 		}
+	} else {
+		// For unstable schema we always need to send everything to a connection.
+		// And we don't want to cache schema for unstable case. But we still need to
+		// set path to a map to make stream visible in UI stream select widget.
+		s.mu.Lock()
+		s.last[path] = nil
+		s.mu.Unlock()
 	}
-
 	// The channel this will be posted into.
 	channel := live.Channel{Scope: live.ScopeStream, Namespace: s.id, Path: path}.String()
 	logger.Debug("Publish data to channel", "channel", channel, "dataLength", len(frameJSON))
@@ -122,7 +133,7 @@ func (s *ManagedStream) getLastPacket(path string) (json.RawMessage, bool) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	schema, ok := s.last[path]
-	return schema, ok
+	return schema, ok && schema != nil
 }
 
 func (s *ManagedStream) GetHandlerForPath(_ string) (models.ChannelHandler, error) {
@@ -145,7 +156,7 @@ func (s *ManagedStream) OnPublish(_ context.Context, _ *models.SignedInUser, evt
 		// Stream scope only deals with data frames.
 		return models.PublishReply{}, 0, err
 	}
-	err = s.Push(evt.Path, &frame)
+	err = s.Push(evt.Path, &frame, true)
 	if err != nil {
 		// Stream scope only deals with data frames.
 		return models.PublishReply{}, 0, err