તમારો SQL ઝડપી છે પરંતુ API ધીમું છે

તમારી ડેટાબેઝ ક્વેરીઝ ઝડપી છે. તમારી કેશિંગ (caching) કામ કરે છે. તમારા બેકગ્રાઉન્ડ જોબ્સ (background jobs) બરાબર છે.

તેમ છતાં, તમારું API હજુ પણ ધીમું છે. તમારો CPU વપરાશ વધારે છે.

સમસ્યા તમારા ડેટાબેઝમાં નથી. સમસ્યા Ruby લેયરમાં છે.

બોટલનેક (bottleneck) અવારનવાર ત્યારે થાય છે જ્યારે ડેટા ડેટાબેઝમાંથી બહાર નીકળીને તમારી એપ્લિકેશનમાં પ્રવેશે છે. આ ત્રણ મુખ્ય સમસ્યાઓ દ્વારા થાય છે:

  • અતિશય સીરીયલાઈઝેશન (Bloated serialization)
  • અતિશય ઓબ્જેક્ટ એલોકેશન (Excessive object allocation)
  • વારંવાર થતી ગણતરી (Repeated computation)

તેમને કેવી રીતે સુધારવા તે અહીં છે.

  1. અતિશય સીરીયલાઈઝેશન બંધ કરો

ઘણા ડેવલપર્સ આખા મોડલ્સને JSON માં ફેરવી નાખે છે.

render json: @shipments

જો કોઈ શિપમેન્ટમાં 40 કોલમ હોય પરંતુ તમારા ફ્રન્ટએન્ડને માત્ર 5 ની જરૂર હોય, તો તમે CPU સાયકલનો બગાડ કરો છો. તમે API કી અથવા ખર્ચ જેવો ખાનગી ડેટા લીક થવાનું જોખમ પણ ઉઠાવો છો.

ઉકેલ: ફક્ત તમને જરૂરી ફિલ્ડ્સ જ રિટર્ન કરો.

render json: @shipments.as_json(only: [:id, :tracking_no, :status])

વધુ સારી ઝડપ માટે, ડેટાને એરે (arrays) તરીકે મેળવવા માટે pluck નો ઉપયોગ કરો. આ ભારે ActiveRecord ઓબ્જેક્ટ્સ બનાવવાનું સંપૂર્ણપણે ટાળે છે.

  1. ઓબ્જેક્ટ એલોકેશન ઘટાડો

Ruby દ્વારા બનાવવામાં આવતો દરેક ઓબ્જેક્ટ મેમરીનો વપરાશ કરે છે. એક જ રિક્વેસ્ટ દરમિયાન હજારો ઓબ્જેક્ટ્સ બનાવવાથી ગાર્બેજ કલેક્ટર (Garbage Collector - GC) ને વધુ મહેનત કરવી પડે છે. આ તમારા સમગ્ર સિસ્ટમને ધીમી પાડે છે.

લૂપ્સ (loops) ની અંદર નવા હેશેસ (hashes) અથવા સ્ટ્રિંગ્સ બનાવવાનું ટાળો.

ખરાબ:

@shipments.map do |s|
  { label: "#{s.tracking_no} - #{s.status.upcase}" }
end

સારું: સ્ટેટિક ડેટાને લૂપની બહાર ખસેડો. Ruby ને બદલે ડેટાબેઝમાં વધુ કામ કરો.

  1. વારંવાર થતી ગણતરી ટાળો

જો તમે એક જ રિક્વેસ્ટમાં એક જ મેથડને અનેક વખત કોલ કરો છો, તો તમે સમય બગાડો છો.

ઉદાહરણ:

def total_weight
  shipments.sum(&:weight)
end

જો તમારું વ્યુ (view), હેલ્પર (helper), અને સીરીયલાઈઝર (serializer) આ બધાને કોલ કરે છે, તો તમે ત્રણ વાર સરવાળો કરો છો.

ઉકેલ: મેમોઈઝેશન (memoization) નો ઉપયોગ કરો.

def total_weight
  @total_weight ||= shipments.sum(&:weight)
end

આ સુનિશ્ચિત કરે છે કે ગણતરી રિક્વેસ્ટ દીઠ માત્ર એક જ વાર થાય.

સારાંશ કોષ્ટક:

  • અતિશય સીરીયલાઈઝેશન: ફક્ત જરૂરી ફિલ્ડ્સ રિટર્ન કરો અથવા pluck નો ઉપયોગ કરો.
  • વધુ એલોકેશન: લૂપ્સમાં ઓછા ઓબ્જેક્ટ્સ બનાવો.
  • વારંવાર થતી ગણતરી: પરિણામોનો ફરીથી ઉપયોગ કરવા માટે મેમોઈઝેશનનો ઉપયોગ કરો.

ડેટાબેઝ ઓપ્ટિમાઇઝેશનનો અર્થ છે ઓછો ડેટા માંગવો. એપ્લિકેશન ઓપ્ટિમાઇઝેશનનો અર્થ છે ડેટા મળ્યા પછી ઓછું બિનજરૂરી કામ કરવું.

Source: https://dev.to/danewu/your-sql-is-fast-but-the-api-is-slow-its-the-ruby-layer-2fno