تقدير المشروع
← كل المقالات

اختبار أداء k6.io بسلاسة لمشاريع Scala باستخدام Scala.js

يتناول هذا المقال كتابة اختبارات k6 بلغة Scala عبر Scala.js، وما يوفره ذلك: ضمانات وقت التجميع، والتركيب الوظيفي، والتكامل المباشر.

8 دقائق قراءة
Scalascala-cliGrafanaاختبار الأداء

نادرًا ما تتعطل أنظمة اليوم بسبب خطأ واحد. بل في أغلب الأحيان تتدهور تحت ضغط الواقع: اندفاعات مفاجئة في حركة البيانات، واستدعاءات كثيرة التواصل بين الخدمات، وتسريبات بطيئة لا تظهر إلا بعد ساعات تحت الحمل. باتت مشكلات الأداء تظهر باستمرار في الإنتاج بدلًا من مرحلة اختبار مخصصة. فقد نقلت بيئات السحابة وقابلية المراقبة التي تركز على SRE التحقق من الحمل من المختبر المضبوط إلى خط التسليم. وإذا اعتمدت على التوسع التلقائي ولوحات المراقبة، فلن تكتشف المشكلات إلا بعد أن تكون قد أضرت بالمستخدمين في الإنتاج.

يعالج K6 بعضًا من هذه المشكلات بتحويل اختبارات الأداء إلى شيفرة: ذات إصدارات، ومؤتمتة، ومتصلة مباشرة بـ CI. غير أن نموذج البرمجة النصية فيه يقتصر على JavaScript، وهذا لا يناسب الفرق التي تبني واجهات خلفية موزعة بلغة Scala. فأنت تتخلى عن أمان الأنواع، وFP patterns*، وعن فرصة إعادة استخدام منطق المجال والمكتبات المشتركة التي تحدد سلوك النظام.

يستكشف هذا المقال طريقًا آخر: كتابة اختبارات k6 بلغة Scala عبر Scala.js. يبقى نموذج التشغيل كما هو، وكذلك منظومة k6. وما نكسبه هو ضمانات وقت التجميع، والتركيب الوظيفي، والتكامل المباشر في المشاريع المبنية بـ Scala. فيصبح اختبار الأداء جزءًا أساسيًا من هندسة البرمجيات بدلًا من القطعة الأخيرة في الأحجية، التي كثيرًا ما يتولاها فريق منفصل. ويمكننا تقصير حلقات التغذية الراجعة، وهذا قد يكمّل نهج «التحول إلى اليمين» (shift-right) المنتشر الذي ينادي به DevOps وSRE.

الخلفية

يُعدّ k6 الآن من أشهر الأدوات لبناء اختبارات الأداء. ويقدّر المطورون ومهندسو ضمان الجودة بساطته ووضوحه وسهولة دمجه.

وبحسب كلمات الوثائق:

Grafana k6 أداة اختبار حمل قابلة للتوسعة ومفتوحة المصدر صُممت مع وضع المطورين في الحسبان. مع k6 يمكنك تجنب مشكلات الأداء وتحسين الموثوقية استباقيًا.

k6 ملف ثنائي مجمّع خفيف مكتوب بلغة GO ويضمّن مفسّر JavaScript المسمى Goja. وهذا التصميم مقايضة متعمدة: فهو يستفيد من نضج منظومة JavaScript وألفتها مع الحفاظ على انخفاض استهلاك الموارد وكفاءة لغة Go. وبناءً عليه تُكتب نصوص الاختبار بـ JavaScript – وهو خيار معقول، إذ يعرف المطورون ومهندسو ضمان الجودة اللغة جيدًا.

يمكن تشغيل الاختبارات محليًا أو في بيئة سحابية بقدر ضئيل جدًا من الشيفرة التمهيدية. ويعمل K6.io جيدًا مع Grafana، ما يتيح مراقبة تشغيل الاختبارات في وقت قريب من الفعلي. وتتيح واجهة الامتدادات فيه استخدام امتدادات المجتمع القائمة أو كتابة امتداداتك الخاصة – مثلًا لدعم بروتوكولات شبكة مخصصة.

لماذا ننظر أبعد من JavaScript؟

قد تكون JavaScript الخيار الافتراضي لكثير من المهندسين، وخاصة العاملين في جودة البرمجيات، لكن الخيارات الأخرى تستحق الاهتمام أيضًا. فلغة Scala، رغم أنها معروفة بتعقيدها، توفر قابلية تشغيل بيني قوية ومجموعة ميزات غنية قد تؤتي ثمارها في اختبار الأداء. والفرق التي تكون قاعدة شيفرتها بـ Scala أصلًا يمكنها أن تستفيد كثيرًا.

سنبيّن هنا نقاط القوة والضعف التي تجلبها Scala، لتحكم هل تناسب حالة استخدامك. وسنوضح أيضًا كيف تدمجها مع مشاريع مبنية ببضع أدوات بناء لـ Scala: sbt وmill وGradle.

لكن قبل ذلك، بضع كلمات عن Scala.js، وهي ما يجعل كل هذا ممكنًا.

Scala.js جسرًا إلى k6

مع Scala.js يمكننا كتابة تطبيقات Scala تُجمَّع إلى JavaScript وتعمل في أي متصفح حديث أو بيئة تشغيل JavaScript. وبذلك يمكنك الاستفادة من الأنواع الساكنة في Scala وميزاتها المتقدمة – بنى البرمجة الوظيفية، والمجموعات القوية، وبنية الجملة التعبيرية – مع استهداف منظومة JavaScript في الوقت نفسه.

وبهذه الطريقة، يمكن لـ Scala.js رفع جودة الشيفرة وقابليتها للصيانة بفضل أمان أنواع أقوى وضمانات مُجمِّع أفضل. كما يتيح لك إعادة استخدام مكتبات Scala القائمة (إلى حد ما) والتكامل بسلاسة مع المنظومة الواسعة لمكتبات JavaScript. وهذا يجعله حلقة وصل قوية بين عالم JVM وبيئة تشغيل JavaScript.

وبعد وضع هذه الأسس، يمكننا الانتقال إلى بناء واجهة (facade) لمكتبة k6 في Scala.js والبدء في صنع نموذج أولي للحل الذي نسعى إليه.

الرحلة: من الفكرة إلى التنفيذ

بدأ استخدام Scala.js مع k6 من ملاحظة بسيطة: يوفر k6 طريقة أنيقة لكتابة اختبارات الأداء بـ JavaScript، لكنه بدا منفصلًا عن المشاريع المكتوبة أصلًا بـ Scala. أردنا مواصلة استخدام نظام أنواع Scala وأدواتها مع الاستفادة في الوقت نفسه من مرونة k6 ومنظومته.

وللتحقق من جدوى ذلك، بنينا مشروع scala-js بسيطًا باستخدام Scala CLI:

//> using scala "3.5.0"
//> using platform scala-js

package example

import scala.scalajs.js
import scala.scalajs.js.annotation.*

@js.native
object k6 extends js.Object {
    def check(response: Response, checks: js.Dictionary[Boolean]): Boolean = js.native
    def sleep(response: Int): Unit = sjs.native
}

@js.native
object http extends js.Object {
    def get(url: String): Response = js.native
}

@js.native
trait Response extends js.Object {
    def body: String = js.native
    def status: Int = js.native
}  

@JSExportTopLevel(JSImport.Default)
object K6ScalaExample {
    @JSExport
    def main(): Unit = {
        val response = Http.get("https://quickpizza.grafana.com/")
    }
}

وبعد أن حصلنا على إثبات بأن النهج يعمل، بنينا واجهة k6 Grafana بـ ScalaJS، ما يجعل الأمور أبسط بكثير:

//> using scala "3.5.0"
//> using platform scala-js
//> using dep "org.scala.js::k6-scala::0.0.1-SNAPSHOT"

package example

import scala.scalajs.js
import scala.scalajs.js.annotation.*
import org.scala.js.k6.http.Http

@JSExportTopLevel(JSImport.Default)
object K6ScalaExample {
    @JSExport
    def main(): Unit = {
        val response = Http.get("https://quickpizza.grafana.com/")
    }
}

التكامل مع أدوات البناء

يبدو هذا جيدًا – تنفيذ مرتب إلى حد كبير. وفي حالة الاختبارات المستقلة قد يكفي أحيانًا، لكن كما قلنا سابقًا، فإن الفائدة الحقيقية تأتي من دمجه في المشاريع القائمة. وفي عالم Scala ثلاث أدوات بناء رئيسية: sbt وmill وGradle. وتتطلب كل منها تثبيت k6 Grafana.

وللتأكد من إمكانية ذلك، أعددنا مشروعًا بسيطًا بالأدوات المناسبة. بالنسبة لـ SBT، كتبنا مهمة بسيطة:

lazy val root = Project("root", file("."))
  .enablePlugins(ScalaJSPlugin)
  .settings(
    scalaVersion := "3.5.0",
    publish / skip := true,
    scalaJSLinkerConfig ~= {
      _.withModuleSplitStyle(ModuleSplitStyle.FewestModules).withModuleKind(ModuleKind.ESModule)
    },
    runK6example := {
      val jsTargetDir = (Compile / fullOptJS / crossTarget).value
      val name = (Compile / fullOptJS / moduleName).value
      val jsOutput = jsTargetDir / s"${name}-fastopt.js"
      val log = streams.value.log
      log.info(s"Using JS output: ${jsOutput.getAbsolutePath()}")
      log.info(s"Running k6 test...")
      val exitCode = Process(Seq("k6", "run", jsOutput.getAbsolutePath)).!
      if (exitCode != 0) {
        log.error("k6 failed!")
      }
    }
)

وبالطريقة نفسها، أضفنا أمرًا لـ mill:

import mill._
import mill.api.Loose
import mill.scalalib._
import mill.scalajslib._
import mill.scalajslib.api._

val projectScalaVersion = "3.5.0"

object helloworld extends ScalaJSModule {

  override def scalaVersion = projectScalaVersion
  override def scalaJSVersion = "1.18.1"
  override def ivyDeps: Target[Loose.Agg[Dep]] = super.ivyDeps() ++ Agg(
    ivy"org.scalajs::k6-scala::0.0.1-SNAPSHOT".withDottyCompat(projectScalaVersion)
  )
  override def moduleKind = ModuleKind.ESModule
  override def moduleSplitStyle = ModuleSplitStyle.FewestModules
  override def sources = T.sources {
    Seq(millSourcePath / "src").map(PathRef(_))
  }

  def runK6test() = T.command {
    val jsFilePath: os.Path = fastLinkJS().dest.path / "main.js"
    println(s"Using JS output: $jsFilePath")
    val exitCode = os.proc("k6", "run", jsFilePath).call(stdout = os.Inherit, stderr = os.Inherit).exitCode
    if (exitCode != 0) {
      throw new Exception("k6 failed!")
    }
  }
}

الأداء والمقاييس

مع حل يعمل وتكاملات أدوات البناء جاهزة، أردنا قياس مقدار الوقت الإضافي الذي قد يكلفه مقارنةً بـ JavaScript «العادية». ولهذا استخدمنا hyperfine، وهي أداة ذات بنية جملة مباشرة جدًا:

hyperfine -r 100 -p 'rm -rf .scala-build/ example.js example.js.map' 'scala-cli --power package example.scala --js --js-emit-source-maps --js-module-kind esmodule -f --js-no-opt'  
hyperfine -r 100 'k6 run example.js'
hyperfine -r 100 'k6 run pure.js'
hyperfine -r 100 -p 'mill clean' 'mill helloworld.fastOpt'
hyperfine -r 100 -p 'sbt clean' 'sbt fastOptJS'
hyperfine -r 100 -p './gradlew clean' './gradlew link'
hyperfine -r 100 'sbt runK6test'
hyperfine -r 100 'mill runK6test'
hyperfine -r 100 './gradlew runK6test'

الافتراضات:

  1. قيس وقت التجميع ووقت التنفيذ بشكل منفصل.
  2. يبدأ التجميع من مساحة عمل نظيفة،
  3. عُدّل النص ليجري 100 تكرار دون إرسال أي طلبات حقيقية.
  4. يُعرض متوسط 100 تكرار فقط.
حزمة التقنيات وقت التجميع وقت التنفيذ
k6.io الأصلي غير متاح 358.5 ms
scala-js مع scala-cli 2.895 s 467.0 ms
scala-js مع sbt 15.214 s 8.735 s
scala-js مع mill 7.402 s 752.1 ms
scala-js مع gradle 10.277 s 4.313 s

تُظهر الأرقام أنه حتى مع مساحة عمل نظيفة، يضيف التجميع بعض الكلفة الإضافية نسبةً إلى زمن تنفيذ الاختبار الكلي. هذا المثال بسيط جدًا، وفي الحالات الواقعية قد يستغرق التجميع وقتًا أطول. ومع ذلك، ففي معظم الأوقات سيُستخدم التجميع التزايدي، ما قد يقلل هذه الكلفة كثيرًا.

ويختلف وقت التنفيذ أيضًا. وقد يأتي ذلك من الشيفرة التمهيدية التي تولّدها نسخة Scala.js وكيف تؤثر في أداء تفسير k6. ويضيف التشغيل عبر أدوات البناء مزيدًا من الكلفة. ومع ذلك، ولأن اختبارات الحمل المعتادة تعمل لدقائق لا لثوانٍ، فلا ينبغي أن تهم هذه الكلفة كثيرًا.

مزايا وعيوب كتابة اختبارات k6 بـ Scala.js

تعطي قياسات الأداء صورة واضحة عن الكلفة الإضافية وقت التشغيل. لكن زمن التنفيذ ليس سوى أحد العوامل التي تحدد هل تناسب Scala.js اختبارات k6. فلنتراجع خطوة وننظر في القائمة الأوسع من المزايا والعيوب.

مزايا كتابة اختبارات k6 بـ Scala.js

  1. أمان الأنواع ودعم بيئة التطوير (IDE)
  2. التكامل مع المشاريع المبنية على Scala (وربما Java)
  3. إمكانية إعادة استخدام منطق المجال
  4. صيانة أبسط للفرق التي تستخدم Scala أصلًا.

عيوب كتابة اختبارات k6 بـ Scala.js

  1. لا يوفر Grafana k6.io دعمًا أصليًا
  2. وقت تجميع وتنفيذ إضافي
  3. لا يمكن تتبع إخفاقات الاختبار إلى الاختبارات الفعلية
  4. مجتمع ومنظومة أصغر
  5. منحنى تعلّم لـ Scala.js (إن لم تكن قد استخدمتها من قبل)
  6. لا يمكن تصحيح الاختبارات، وإن كان هذا ينطبق على Grafana k6.io عمومًا.

الخلاصة

بلا شك، JavaScript هي اللغة المعتمدة مع k6. فهي بيئة التشغيل الأصلية، وواسعة الاستخدام، وموثقة بشكل استثنائي. وبالنسبة لمعظم الفرق، وخاصة التي تخطو خطواتها الأولى في اختبار الأداء، فإن JavaScript أسرع طريق إلى النتائج بأقل إعداد.

فمتى تستحق Scala.js العناء؟

كما ذُكر سابقًا، تصبح Scala خيارًا جذابًا عندما تعمل أصلًا في منظومة Scala – خاصة في قواعد الشيفرة الكبيرة الآمنة الأنواع حيث يجب أن تبقى اختبارات الأداء متوافقة بشكل وثيق مع النماذج أو المنطق القائم.

وإلى جانب ذلك، قد تناسبك Scala.js جيدًا إذا كنت:

  • تهتم بأمان الأنواع لاكتشاف المشكلات مبكرًا وجعل الاختبارات أكثر موثوقية
  • تفضّل أسلوب البرمجة الوظيفية لتركيب الاختبارات ومنطقها
  • ترغب في إعادة استخدام منطق المجال أو نماذج البيانات مباشرة في اختبارات الأداء

ومع ذلك، يجب الاعتراف بالقيود الحالية: فالنهج لا يزال في مرحلة مبكرة. يبدو واعدًا، لكنه يحتاج إلى مزيد من العمل ليصبح جاهزًا تمامًا للإنتاج – ومن ذلك تغطية كاملة للواجهات البرمجية، وتغليف ونشر سليمان، وأدوات أفضل، وتكامل سلس مع بيئة التشغيل.

روابط ومصادر

  1. وثائق Scala.js
  2. Grafana k6

** توفر JavaScript حفنة من الأوليات الوظيفية، لكن بلا أنواع ساكنة تبقى أعرافًا لا ضمانات.*