simple template

Signed-off-by: Jason Chenyang Ji <chenyang.yale@gmail.com>

Author: ansjcy

src/main/java/org/opensearch/plugin/insights/QueryInsightsPlugin.java

@@ -148,7 +148,7 @@ public List<Setting<?>> getSettings() {
             QueryCategorizationSettings.SEARCH_QUERY_METRICS_ENABLED_SETTING,
             QueryInsightsSettings.TOP_N_EXPORTER_DELETE_AFTER,
             QueryInsightsSettings.TOP_N_EXPORTER_TYPE,
-            QueryInsightsSettings.TOP_N_EXPORTER_TEMPLATE_ORDER,
+            QueryInsightsSettings.TOP_N_EXPORTER_TEMPLATE_PRIORITY,
             QueryCategorizationSettings.SEARCH_QUERY_FIELD_TYPE_CACHE_SIZE_KEY
         );
     }

src/main/java/org/opensearch/plugin/insights/core/exporter/LocalIndexExporter.java

@@ -71,7 +71,8 @@ public class LocalIndexExporter implements QueryInsightsExporter {
     );
     private static final List<String> DEFAULT_SORTED_ORDERS = List.of("desc", "desc", "desc");
     private static final String TEMPLATE_NAME = "query_insights_override";
-    private int templateOrder;
+    private static final long DEFAULT_TEMPLATE_PRIORITY = 1000L;
+    private long templatePriority;
 
     /**
      * Constructor
@@ -95,7 +96,7 @@ public LocalIndexExporter(
         this.indexMapping = indexMapping;
         this.id = id;
         this.deleteAfter = DEFAULT_DELETE_AFTER_VALUE;
-        this.templateOrder = QueryInsightsSettings.DEFAULT_TEMPLATE_ORDER;
+        this.templatePriority = DEFAULT_TEMPLATE_PRIORITY;
     }
 
     /**
@@ -144,23 +145,7 @@ public void export(final List<SearchQueryRecord> records) {
         try {
             final String indexName = buildLocalIndexName();
             if (!checkIndexExists(indexName)) {
-                // Check for conflicting templates once and reuse results
-                TemplateConflictInfo conflictInfo = findConflictingTemplatesWithDetails();
-                if (!conflictInfo.getConflictingTemplates().isEmpty()) {
-                    logger.warn("Detected potentially conflicting templates: {}", conflictInfo.getConflictingTemplates());
-                }
-                
-                // Adjust the template order if needed based on conflict info
-                if (conflictInfo.getHighestOrder() > 0) {
-                    int adjustedOrder = calculateAdjustedOrder(conflictInfo.getHighestOrder());
-                    if (adjustedOrder > templateOrder) {
-                        logger.debug("Adjusting template order from {} to {} due to conflicting templates", 
-                            templateOrder, adjustedOrder);
-                        templateOrder = adjustedOrder;
-                    }
-                }
-                
-                // Create template with adjusted order
+                // Create template with fixed priority
                 ensureTemplateExists();
 
                 CreateIndexRequest createIndexRequest = new CreateIndexRequest(indexName);
@@ -202,15 +187,7 @@ public void onFailure(Exception e) {
                             }
                         } else {
                             OperationalMetricsCounter.getInstance().incrementCounter(OperationalMetric.LOCAL_INDEX_EXPORTER_EXCEPTIONS);
-                            
-                            // Use the conflict info we already have for error reporting
-                            if (cause.getMessage() != null && cause.getMessage().contains("index sort field")) {
-                                logger.error("Index creation failed due to sort field issue. This is likely caused by a conflicting template. " +
-                                    "Detected templates: {}. Try increasing the template order value or removing conflicting templates.", 
-                                    conflictInfo.getConflictingTemplates(), cause);
-                            } else {
-                                logger.error("Unable to create query insights index: ", cause);
-                            }
+                            logger.error("Unable to create query insights index: ", cause);
                         }
                     }
                 });
@@ -349,75 +326,12 @@ private Map<String, Object> readIndexMappingsAsMap() throws IOException {
     }
 
     /**
-     * Check if our template exists
-     * @param templateName template name to check
-     * @return true if template exists, false otherwise
-     */
-    private boolean checkTemplateExists(String templateName) {
-        try {
-            ClusterState state = clusterService.state();
-            return state.getMetadata().templates().containsKey(templateName);
-        } catch (Exception e) {
-            logger.error("Error checking template existence [{}]", templateName, e);
-            return false;
-        }
-    }
-
-    /**
-     * Ensure a template exists for our index pattern with a high priority
-     * to override any wildcard templates
+     * Ensure a template exists for our index pattern with the configured priority
      */
     private void ensureTemplateExists() {
         String indexPattern = TOP_QUERIES_INDEX_PATTERN_GLOB;
 
-        // First check for any templates we need to compete with and adjust order if needed
-        templateOrder = getAdjustedTemplateOrder();
-        
         try {
-            boolean templateNeedsCreation = true;
-            boolean templateNeedsUpdate = false;
-            int existingPriority = -1;
-            
-            // Check if our template exists in V2 templates
-            ClusterState state = clusterService.state();
-            if (state.getMetadata().templatesV2().containsKey(TEMPLATE_NAME)) {
-                templateNeedsCreation = false;
-                org.opensearch.cluster.metadata.ComposableIndexTemplate existingTemplate = 
-                    state.getMetadata().templatesV2().get(TEMPLATE_NAME);
-                
-                if (existingTemplate != null) {
-                    Integer currentPriority = existingTemplate.priority();
-                    existingPriority = currentPriority != null ? currentPriority : 0;
-                    if (existingPriority < templateOrder) {
-                        templateNeedsUpdate = true;
-                        logger.debug("Existing template [{}] priority {} needs to be updated to {}", 
-                            TEMPLATE_NAME, existingPriority, templateOrder);
-                    }
-                }
-            } else {
-                // Also check in V1 templates for backward compatibility
-                if (state.getMetadata().templates().containsKey(TEMPLATE_NAME)) {
-                    // If a V1 template exists, we'll replace it with a V2 template
-                    templateNeedsCreation = false;
-                    templateNeedsUpdate = true;
-                    org.opensearch.cluster.metadata.IndexTemplateMetadata existingTemplate = 
-                        state.getMetadata().templates().get(TEMPLATE_NAME);
-                    
-                    if (existingTemplate != null) {
-                        Integer currentOrder = existingTemplate.order();
-                        existingPriority = currentOrder != null ? currentOrder : 0;
-                        logger.debug("Found old V1 template [{}] with order {}. Will replace with V2 template.", 
-                            TEMPLATE_NAME, existingPriority);
-                    }
-                }
-            }
-            
-            // Skip if template exists and doesn't need updating
-            if (!templateNeedsCreation && !templateNeedsUpdate) {
-                logger.debug("Template [{}] already exists with appropriate priority", TEMPLATE_NAME);
-                return;
-            }
-            
             // Create a V2 template (ComposableIndexTemplate)
             String mappingContent = readIndexMappings();
             org.opensearch.core.xcontent.XContentType xContentType = org.opensearch.core.xcontent.XContentType.JSON;
@@ -442,8 +356,8 @@ private void ensureTemplateExists() {
                     Collections.singletonList(indexPattern),
                     template,
                     null, // No composed_of templates
-                    templateOrder, // Priority (using the same value as our adjusted order)
-                    templateOrder, // Version (using order as version for tracking changes)
+                    templatePriority, // Priority using configured value
+                    1L, // Version
                     null, // No metadata
                     null // No data stream
                 );
@@ -460,18 +374,16 @@ private void ensureTemplateExists() {
                     @Override
                     public void onResponse(org.opensearch.action.support.AcknowledgedResponse response) {
                         if (response.isAcknowledged()) {
-                            logger.info("Successfully {} V2 template [{}] with priority {}", 
-                                templateNeedsCreation ? "created" : "updated", TEMPLATE_NAME, templateOrder);
+                            logger.info("Successfully created or updated V2 template [{}] with priority {}", 
+                                TEMPLATE_NAME, templatePriority);
                         } else {
-                            logger.warn("Failed to {} V2 template [{}]", 
-                                templateNeedsCreation ? "create" : "update", TEMPLATE_NAME);
+                            logger.warn("Failed to create or update V2 template [{}]", TEMPLATE_NAME);
                         }
                     }
 
                     @Override
                     public void onFailure(Exception e) {
-                        logger.error("Error {} V2 template [{}]", 
-                            templateNeedsCreation ? "creating" : "updating", TEMPLATE_NAME, e);
+                        logger.error("Error creating or updating V2 template [{}]", TEMPLATE_NAME, e);
                         OperationalMetricsCounter.getInstance().incrementCounter(OperationalMetric.LOCAL_INDEX_EXPORTER_EXCEPTIONS);
                     }
                 }
@@ -483,161 +395,19 @@ public void onFailure(Exception e) {
     }
 
     /**
-     * Find templates that might conflict with our index creation and collect information about them
-     * @return TemplateConflictInfo containing conflicting templates and their highest order/priority
-     */
-    private TemplateConflictInfo findConflictingTemplatesWithDetails() {
-        List<String> conflictingTemplates = new ArrayList<>();
-        int highestOrder = 0;
-
-        try {
-            ClusterState state = clusterService.state();
-            String ourIndexPattern = TOP_QUERIES_INDEX_PATTERN_GLOB;
-            
-            // Find V1 templates that match our index pattern
-            state.getMetadata().templates().forEach((name, template) -> {
-                for (String pattern : template.patterns()) {
-                    // Check if this template would match our index pattern
-                    if (pattern.equals("*") || ourIndexPattern.matches(patternToRegex(pattern))) {
-                        // Only process templates not created by us
-                        if (!name.startsWith(TEMPLATE_NAME)) {
-                            Integer order = template.order();
-                            int orderValue = order != null ? order : 0;
-                            
-                            // Track the highest order value
-                            if (orderValue > highestOrder) {
-                                highestOrder = orderValue;
-                            }
-                            
-                            conflictingTemplates.add(name + " (V1, pattern: " + pattern + ", order: " + 
-                                (order != null ? order : "default") + ")");
-                        }
-                    }
-                }
-            });
-            
-            // Also check V2 templates (composable templates)
-            state.getMetadata().templatesV2().forEach((name, template) -> {
-                List<String> patterns = template.indexPatterns();
-                for (String pattern : patterns) {
-                    // Check if this template would match our index pattern
-                    if (pattern.equals("*") || ourIndexPattern.matches(patternToRegex(pattern))) {
-                        // Only process templates not created by us
-                        if (!name.startsWith(TEMPLATE_NAME)) {
-                            // For V2 templates, priority is analogous to order in V1
-                            Integer priority = template.priority();
-                            int priorityValue = priority != null ? priority : 0;
-                            
-                            // Track the highest priority value (to compare with V1 order)
-                            if (priorityValue > highestOrder) {
-                                highestOrder = priorityValue;
-                            }
-                            
-                            conflictingTemplates.add(name + " (V2, pattern: " + pattern + ", priority: " + 
-                                (priority != null ? priority : "default") + ")");
-                        }
-                    }
-                }
-            });
-        } catch (Exception e) {
-            logger.error("Error checking for conflicting templates", e);
-        }
-        
-        return new TemplateConflictInfo(conflictingTemplates, highestOrder);
-    }
-    
-    /**
-     * Convert an index pattern to a regex for matching
-     */
-    private String patternToRegex(String pattern) {
-        return pattern
-            .replace(".", "\\.")
-            .replace("*", ".*")
-            .replace("?", ".");
-    }
-
-    /**
-     * Find templates that might conflict with our index creation
-     * @return List of potentially conflicting template names
-     */
-    private List<String> findConflictingTemplates() {
-        return findConflictingTemplatesWithDetails().getConflictingTemplates();
-    }
-    
-    /**
-     * Ensure we're using a template order higher than any conflicting template
-     * @return The adjusted template order
-     */
-    private int getAdjustedTemplateOrder() {
-        TemplateConflictInfo conflictInfo = findConflictingTemplatesWithDetails();
-        return calculateAdjustedOrder(conflictInfo.getHighestOrder());
-    }
-    
-    /**
-     * Calculate the adjusted order value based on a conflicting order
-     * @param highestConflictingOrder The highest order value found in conflicting templates
-     * @return The adjusted order value
-     */
-    private int calculateAdjustedOrder(int highestConflictingOrder) {
-        // If no conflicts, return the current order
-        if (highestConflictingOrder <= 0) {
-            return templateOrder;
-        }
-        
-        // Add a buffer to ensure we're substantially higher
-        int adjustedOrder = highestConflictingOrder + 100;
-        
-        // If template order gets too high, we might approach Integer.MAX_VALUE
-        // In that case, use a very high value but leave room for future conflicts
-        if (adjustedOrder > Integer.MAX_VALUE - 1000) {
-            adjustedOrder = Integer.MAX_VALUE - 1000;
-        }
-        
-        // Only log if we're actually changing the order
-        if (adjustedOrder > templateOrder) {
-            logger.debug("Adjusting template order from {} to {} due to conflicting templates with highest order/priority {}",
-                templateOrder, adjustedOrder, highestConflictingOrder);
-            return adjustedOrder;
-        }
-        
-        return templateOrder;
-    }
-    
-    /**
-     * Value class to hold information about conflicting templates
-     */
-    private static class TemplateConflictInfo {
-        private final List<String> conflictingTemplates;
-        private final int highestOrder;
-        
-        TemplateConflictInfo(List<String> conflictingTemplates, int highestOrder) {
-            this.conflictingTemplates = conflictingTemplates;
-            this.highestOrder = highestOrder;
-        }
-        
-        List<String> getConflictingTemplates() {
-            return conflictingTemplates;
-        }
-        
-        int getHighestOrder() {
-            return highestOrder;
-        }
-    }
-
-    /**
-     * Set the template order for the exporter
-     * @param templateOrder New template order value
+     * Set the template priority for the exporter
+     * @param templatePriority New template priority value
      */
-    public void setTemplateOrder(final int templateOrder) {
-        this.templateOrder = templateOrder;
+    public void setTemplatePriority(final long templatePriority) {
+        this.templatePriority = templatePriority;
     }
 
     /**
-     * Get the current template order
-     * @return Current template order value
+     * Get the current template priority
+     * @return Current template priority value
      */
-    public int getTemplateOrder() {
-        return templateOrder;
+    public long getTemplatePriority() {
+        return templatePriority;
     }
 
 }