Comprehensive comparison for Search technology in Software Development applications

const apm = require('elastic-apm-node').start({
  serviceName: 'search-service',
  secretToken: process.env.APM_SECRET_TOKEN,
  serverUrl: process.env.APM_SERVER_URL,
  environment: process.env.NODE_ENV || 'development',
  captureBody: 'all',
  transactionSampleRate: 1.0
});

const express = require('express');
const { Client } = require('@elastic/elasticsearch');
const app = express();

const esClient = new Client({
  node: process.env.ELASTICSEARCH_URL || 'http://localhost:9200'
});

app.use(express.json());

// Software development search endpoint with APM instrumentation
app.post('/api/search/code', async (req, res) => {
  const transaction = apm.currentTransaction;
  
  try {
    const { query, filters = {}, page = 1, pageSize = 20 } = req.body;
    
    // Validate input
    if (!query || query.trim().length === 0) {
      apm.captureError(new Error('Empty search query'));
      return res.status(400).json({ error: 'Query parameter is required' });
    }
    
    // Add custom context to transaction
    if (transaction) {
      transaction.setLabel('search_query', query);
      transaction.setLabel('page', page);
      transaction.addLabels({ language: filters.language || 'all' });
    }
    
    // Create custom span for search operation
    const searchSpan = apm.startSpan('elasticsearch.search.code', 'db.elasticsearch');
    
    const searchBody = {
      query: {
        bool: {
          must: [
            {
              multi_match: {
                query: query,
                fields: ['content^3', 'filename^2', 'repository', 'description'],
                type: 'best_fields',
                fuzziness: 'AUTO'
              }
            }
          ],
          filter: []
        }
      },
      highlight: {
        fields: {
          content: { fragment_size: 150, number_of_fragments: 3 },
          filename: {}
        }
      },
      from: (page - 1) * pageSize,
      size: pageSize,
      sort: [{ _score: 'desc' }, { updated_at: 'desc' }]
    };
    
    // Apply filters
    if (filters.language) {
      searchBody.query.bool.filter.push({ term: { language: filters.language } });
    }
    if (filters.repository) {
      searchBody.query.bool.filter.push({ term: { 'repository.keyword': filters.repository } });
    }
    
    const result = await esClient.search({
      index: 'code-repository',
      body: searchBody
    });
    
    if (searchSpan) searchSpan.end();
    
    // Track search metrics
    apm.setCustomContext({
      search_results_count: result.hits.total.value,
      search_took_ms: result.took,
      max_score: result.hits.max_score
    });
    
    // Format response
    const formattedResults = result.hits.hits.map(hit => ({
      id: hit._id,
      score: hit._score,
      filename: hit._source.filename,
      repository: hit._source.repository,
      language: hit._source.language,
      content: hit._source.content,
      highlights: hit.highlight || {},
      updated_at: hit._source.updated_at
    }));
    
    res.json({
      total: result.hits.total.value,
      page,
      pageSize,
      results: formattedResults,
      took: result.took
    });
    
  } catch (error) {
    // Capture error with additional context
    apm.captureError(error, {
      custom: {
        query: req.body.query,
        filters: req.body.filters,
        user_agent: req.headers['user-agent']
      }
    });
    
    console.error('Search error:', error);
    res.status(500).json({ 
      error: 'Search failed',
      message: error.message 
    });
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Search service running on port ${PORT}`);
});