Merge branch 'master' into feature/edta-event-def-suggestions

Author: dennisoelkers

UPGRADING.md

@@ -18,3 +18,9 @@ After upgrading:
   matched only `test` now also matches `Test` and `TEST`. API clients relying on exact-case matching
   via paginated endpoints will see additional results.
 
+## Java API Changes
+
+| File/method                                                               | Description |
+|---------------------------------------------------------------------------|-------------|
+| `org.graylog2.contentpacks.facades.EntityWithExcerptFacade#resolveGrants` | removed     |
+

changelog/unreleased/issue-26025.toml

@@ -0,0 +1,5 @@
+type = "f"
+message = "Fix false `Message failed to process` errors when a pipeline rule or extractor assigns a string `timestamp` field in ISO-8601 format. Such timestamps are now parsed leniently instead of being recorded as a processing failure."
+
+issues = ["26025"]
+pulls = ["26269"]

changelog/unreleased/pr-26008.toml

@@ -0,0 +1,5 @@
+type = "fixed" # One of: a(dded), c(hanged), d(eprecated), r(emoved), f(ixed), s(ecurity)
+message = "Fix MCP server 500 error on unknown client capability fields"
+
+issues = ["25956"]
+pulls = ["26008"]

changelog/unreleased/pr-26244.toml

@@ -0,0 +1,4 @@
+type = "f"
+message = "Fix Inputs Metrics telemetry not being reported."
+
+pulls = ["26244"]

graylog2-server/src/main/java/org/graylog/events/contentpack/facade/EventDefinitionFacade.java

@@ -31,11 +31,8 @@
 import org.graylog.events.processor.EventDefinitionDto;
 import org.graylog.events.processor.EventDefinitionHandler;
 import org.graylog.events.processor.EventProcessorExecutionJob;
-import org.graylog.grn.GRNTypes;
 import org.graylog.scheduler.DBJobDefinitionService;
 import org.graylog.scheduler.JobDefinitionDto;
-import org.graylog.security.GrantDTO;
-import org.graylog.security.shares.EntityGrantLookup;
 import org.graylog2.contentpacks.EntityDescriptorIds;
 import org.graylog2.contentpacks.facades.EntityFacade;
 import org.graylog2.contentpacks.facades.UpdatableEntityFacade;
@@ -58,7 +55,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
@@ -73,23 +69,20 @@ public class EventDefinitionFacade implements EntityFacade<EventDefinitionDto>,
     private final DBEventDefinitionService eventDefinitionService;
     private final Set<PluginMetaData> pluginMetaData;
     private final UserService userService;
-    private final EntityGrantLookup grantLookup;
 
     @Inject
     public EventDefinitionFacade(ObjectMapper objectMapper,
                                  EventDefinitionHandler eventDefinitionHandler,
                                  Set<PluginMetaData> pluginMetaData,
                                  DBJobDefinitionService jobDefinitionService,
                                  DBEventDefinitionService eventDefinitionService,
-                                 UserService userService,
-                                 EntityGrantLookup grantLookup) {
+                                 UserService userService) {
         this.objectMapper = objectMapper;
         this.pluginMetaData = pluginMetaData;
         this.eventDefinitionHandler = eventDefinitionHandler;
         this.jobDefinitionService = jobDefinitionService;
         this.eventDefinitionService = eventDefinitionService;
         this.userService = userService;
-        this.grantLookup = grantLookup;
     }
 
     @VisibleForTesting
@@ -251,11 +244,6 @@ public boolean usesScopedEntities() {
         return true;
     }
 
-    @Override
-    public List<GrantDTO> resolveGrants(EventDefinitionDto nativeEntity) {
-        return grantLookup.getGrantsForTarget(GRNTypes.EVENT_DEFINITION, nativeEntity.id());
-    }
-
     @Override
     public Optional<EntityPermissions> getCreatePermissions(Entity entity) {
         return EntityPermissions.of(RestPermissions.EVENT_DEFINITIONS_CREATE);

graylog2-server/src/main/java/org/graylog/mcp/server/McpProtocolObjectMapper.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2020 Graylog, Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the Server Side Public License, version 1,
+ * as published by MongoDB, Inc.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Server Side Public License for more details.
+ *
+ * You should have received a copy of the Server Side Public License
+ * along with this program. If not, see
+ * <http://www.mongodb.com/licensing/server-side-public-license>.
+ */
+package org.graylog.mcp.server;
+
+import com.google.inject.BindingAnnotation;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * Qualifier annotation for the ObjectMapper used to deserialize MCP protocol messages.
+ * This mapper is a plain ObjectMapper configured with FAIL_ON_UNKNOWN_PROPERTIES=false,
+ * unlike the global Graylog ObjectMapper which adds SnakeCaseStrategy and custom modules
+ * that interfere with the MCP SDK's own Jackson annotations.
+ *
+ * Workaround for <a href="https://github.com/modelcontextprotocol/java-sdk/issues/766">java-sdk#766</a>.
+ * Remove once the SDK adds @JsonIgnoreProperties(ignoreUnknown=true) to its capability records.
+ */
+@BindingAnnotation
+@Target({FIELD, PARAMETER, METHOD})
+@Retention(RUNTIME)
+public @interface McpProtocolObjectMapper {
+}

graylog2-server/src/main/java/org/graylog/mcp/server/McpRestResource.java

@@ -64,7 +64,7 @@ public class McpRestResource extends RestResource {
     private static final String HEADER_MCP_SESSION_ID = "Mcp-Session-Id";
     private static final String HEADER_MCP_PROTOCOL_VERSION = "MCP-Protocol-Version";
 
-    private final ObjectMapper objectMapper;
+    private final ObjectMapper protocolObjectMapper;
 
     private final McpService mcpService;
 
@@ -73,10 +73,10 @@ public class McpRestResource extends RestResource {
     private final ClusterConfigService clusterConfig;
 
     @Inject
-    public McpRestResource(final ClusterConfigService clusterConfig, final McpService mcpService, final ObjectMapper objectMapper, final SecurityContext securityContext) {
+    public McpRestResource(final ClusterConfigService clusterConfig, final McpService mcpService, @McpProtocolObjectMapper final ObjectMapper protocolObjectMapper, final SecurityContext securityContext) {
         this.clusterConfig = clusterConfig;
         this.mcpService = mcpService;
-        this.objectMapper = objectMapper;
+        this.protocolObjectMapper = protocolObjectMapper;
         this.securityContext = securityContext;
     }
 
@@ -116,7 +116,7 @@ public Response post(@HeaderParam(HttpHeaders.ACCEPT) String acceptHeader,
             // Simple one-shot JSON reply
             Object id = null;
             try {
-                final McpSchema.JSONRPCRequest request = objectMapper.convertValue(payload, McpSchema.JSONRPCRequest.class);
+                final McpSchema.JSONRPCRequest request = protocolObjectMapper.convertValue(payload, McpSchema.JSONRPCRequest.class);
                 LOG.trace("Received JSON-RPC request {}", request);
                 id = request.id();
 
@@ -140,7 +140,7 @@ public Response post(@HeaderParam(HttpHeaders.ACCEPT) String acceptHeader,
                 final Optional<McpSchema.Result> result = mcpService.handle(permissionHelper, request, sessionId, protocolVersionHeader);
 
                 if (result.isPresent() && LOG.isTraceEnabled()) {
-                    LOG.trace("Successfully handled JSON-RPC request: {}", objectMapper.writeValueAsString(result));
+                    LOG.trace("Successfully handled JSON-RPC request: {}", protocolObjectMapper.writeValueAsString(result));
                 }
                 return Response.ok(new McpSchema.JSONRPCResponse("2.0", id, result.orElse(null), null))
                         .header(HEADER_MCP_SESSION_ID, sessionId)

graylog2-server/src/main/java/org/graylog/mcp/server/McpServerModule.java

@@ -16,6 +16,8 @@
  */
 package org.graylog.mcp.server;
 
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import org.graylog.mcp.resources.DashboardResourceProvider;
 import org.graylog.mcp.resources.EventDefinitionResourceProvider;
 import org.graylog.mcp.resources.StreamResourceProvider;
@@ -36,6 +38,12 @@
 public class McpServerModule extends PluginModule {
     @Override
     protected void configure() {
+        // Workaround for https://github.com/modelcontextprotocol/java-sdk/issues/766
+        // Remove once the SDK adds @JsonIgnoreProperties(ignoreUnknown=true) to capability records.
+        bind(ObjectMapper.class).annotatedWith(McpProtocolObjectMapper.class)
+                .toInstance(new ObjectMapper()
+                        .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false));
+
         // Initialize schema module binder (empty set by default, plugins can contribute)
         schemaModuleBinder();
 

graylog2-server/src/main/java/org/graylog/mcp/server/McpService.java

@@ -59,6 +59,7 @@ public class McpService {
     static final List<String> ALL_SUPPORTED_MCP_VERSIONS = List.of(LATEST_SUPPORTED_MCP_VERSION);
 
     private final ObjectMapper objectMapper;
+    private final ObjectMapper protocolObjectMapper;
     private final AuditEventSender auditEventSender;
     private final CustomizationConfig customizationConfig;
     private final GRNRegistry grnRegistry;
@@ -67,12 +68,14 @@ public class McpService {
 
     @Inject
     protected McpService(ObjectMapper objectMapper,
+                         @McpProtocolObjectMapper ObjectMapper protocolObjectMapper,
                          AuditEventSender auditEventSender,
                          CustomizationConfig customizationConfig,
                          GRNRegistry grnRegistry,
                          Map<String, Tool<?, ?>> tools,
                          Map<GRNType, ? extends ResourceProvider> resourceProviders) {
         this.objectMapper = objectMapper;
+        this.protocolObjectMapper = protocolObjectMapper;
         this.auditEventSender = auditEventSender;
         this.customizationConfig = customizationConfig;
         this.grnRegistry = grnRegistry;
@@ -93,7 +96,7 @@ public Optional<McpSchema.Result> handle(PermissionHelper permissionHelper, McpS
 
         switch (request.method()) {
             case McpSchema.METHOD_INITIALIZE -> {
-                final McpSchema.InitializeRequest initializeRequest = objectMapper.convertValue(request.params(), new TypeReference<>() {});
+                final McpSchema.InitializeRequest initializeRequest = protocolObjectMapper.convertValue(request.params(), new TypeReference<>() {});
                 auditContext.put("request", initializeRequest);
                 final McpSchema.InitializeResult result = new McpSchema.InitializeResult(
                         // Version negotiation: https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle#version-negotiation
@@ -130,7 +133,7 @@ public Optional<McpSchema.Result> handle(PermissionHelper permissionHelper, McpS
                 return Optional.of(result);
             }
             case McpSchema.METHOD_RESOURCES_READ -> {
-                final McpSchema.ReadResourceRequest readResourceRequest = objectMapper.convertValue(request.params(), new TypeReference<>() {});
+                final McpSchema.ReadResourceRequest readResourceRequest = protocolObjectMapper.convertValue(request.params(), new TypeReference<>() {});
                 auditContext.put("request", readResourceRequest);
                 LOG.debug("Reading resource: {}", readResourceRequest);
                 try {
@@ -181,7 +184,7 @@ public Optional<McpSchema.Result> handle(PermissionHelper permissionHelper, McpS
                 return Optional.of(new McpSchema.ListToolsResult(toolList, null));
             }
             case McpSchema.METHOD_TOOLS_CALL -> {
-                final McpSchema.CallToolRequest callToolRequest = objectMapper.convertValue(request.params(), new TypeReference<>() {});
+                final McpSchema.CallToolRequest callToolRequest = protocolObjectMapper.convertValue(request.params(), new TypeReference<>() {});
                 auditContext.put("request", callToolRequest);
 
                 LOG.debug("Calling MCP tool: {}", callToolRequest);
@@ -237,7 +240,7 @@ public Optional<McpSchema.Result> handle(PermissionHelper permissionHelper, McpS
             }
             case McpSchema.METHOD_PROMPT_GET -> {
                 // disabled for now
-                final McpSchema.GetPromptRequest promptRequest = objectMapper.convertValue(request.params(), new TypeReference<>() {});
+                final McpSchema.GetPromptRequest promptRequest = protocolObjectMapper.convertValue(request.params(), new TypeReference<>() {});
                 auditContext.put("request", promptRequest);
                 LOG.debug("Getting prompt {}", promptRequest.name());
                 auditEventSender.failure(auditActor, AuditEventType.create(MCP_PROMPT_GET), auditContext);