Recherche avancée
Médias (91)
-
GetID3 - Boutons supplémentaires
9 avril 2013, par
Mis à jour : Avril 2013
Langue : français
Type : Image
-
Core Media Video
4 avril 2013, par
Mis à jour : Juin 2013
Langue : français
Type : Video
-
The pirate bay depuis la Belgique
1er avril 2013, par
Mis à jour : Avril 2013
Langue : français
Type : Image
-
Bug de détection d’ogg
22 mars 2013, par
Mis à jour : Avril 2013
Langue : français
Type : Video
-
Exemple de boutons d’action pour une collection collaborative
27 février 2013, par
Mis à jour : Mars 2013
Langue : français
Type : Image
-
Exemple de boutons d’action pour une collection personnelle
27 février 2013, par
Mis à jour : Février 2013
Langue : English
Type : Image
Autres articles (24)
-
(Dés)Activation de fonctionnalités (plugins)
18 février 2011, parPour gérer l’ajout et la suppression de fonctionnalités supplémentaires (ou plugins), MediaSPIP utilise à partir de la version 0.2 SVP.
SVP permet l’activation facile de plugins depuis l’espace de configuration de MediaSPIP.
Pour y accéder, il suffit de se rendre dans l’espace de configuration puis de se rendre sur la page "Gestion des plugins".
MediaSPIP est fourni par défaut avec l’ensemble des plugins dits "compatibles", ils ont été testés et intégrés afin de fonctionner parfaitement avec chaque (...) -
Le plugin : Podcasts.
14 juillet 2010, parLe problème du podcasting est à nouveau un problème révélateur de la normalisation des transports de données sur Internet.
Deux formats intéressants existent : Celui développé par Apple, très axé sur l’utilisation d’iTunes dont la SPEC est ici ; Le format "Media RSS Module" qui est plus "libre" notamment soutenu par Yahoo et le logiciel Miro ;
Types de fichiers supportés dans les flux
Le format d’Apple n’autorise que les formats suivants dans ses flux : .mp3 audio/mpeg .m4a audio/x-m4a .mp4 (...) -
Les autorisations surchargées par les plugins
27 avril 2010, parMediaspip core
autoriser_auteur_modifier() afin que les visiteurs soient capables de modifier leurs informations sur la page d’auteurs
Sur d’autres sites (7226)
-
FFmpegAudio object has no attribute _process
28 janvier 2023, par Benjamin TsoumagasI'm trying to make a Discord music bot that is remotely hosted and to do that I need ffmpeg to work. I was able to add it using my Dockerfile but upon trying to play music with the bot I get the following errors. For context, I am hosting on Fly.io and using python with the Nextcord library. Below is my relevant code and the error message. Please let me know if any more information is required.


import nextcord, os, json, re, youtube_dl
from nextcord import Interaction, application_checks
from nextcord.ext import commands

youtube_dl.utils.bug_reports_message = lambda: ''

ytdl_format_options = {
 "format": "bestaudio/best",
 'outtmpl': '%(extractor)s-%(id)s-%(title)s.%(ext)s',
 'restrictfilenames': True,
 'noplaylist': True,
 'nocheckcertificate': True,
 'ignoreerrors': False,
 'logtostderr': False,
 'quiet': True,
 'no_warnings': True,
 'default_search': 'auto',
 'source_address': '0.0.0.0',
}

ffmpeg_options = {"options": "-vn"}

ytdl = youtube_dl.YoutubeDL(ytdl_format_options)

class YTDLSource(nextcord.PCMVolumeTransformer):
 def __init__(self, source, *, data, volume=0.5):
 super().__init__(source, volume)
 self.data = data
 self.title = data.get("title")
 self.url = data.get("url")

 @classmethod
 async def from_url(cls, url, *, loop=None, stream=False):
 loop = loop or asyncio.get_event_loop()
 data = await loop.run_in_executor(None, lambda: ytdl.extract_info(url, download=not stream))

 if "entries" in data:
 data = data["entries"][0]
 
 filename = data["url"] if stream else ytdl.prepare_filename(data)
 return cls(nextcord.FFmpegAudio(filename, *ffmpeg_options), data=data)

async def ensure_voice(interaction: Interaction):
 if interaction.guild.voice_client is None:
 if interaction.user.voice:
 await interaction.user.voice.channel.connect()
 else:
 await interaction.send("You are not connected to a voice channel.")
 raise commands.CommandError("Author not connected to a voice channel.")
 elif interaction.guild.voice_client.is_playing():
 interaction.guild.voice_client.stop()

class Music(commands.Cog, name="Music"):
 """Commands for playing music in voice channels"""

 COG_EMOJI = "🎵"

 def __init__(self, bot):
 self.bot = bot
 
 @application_checks.application_command_before_invoke(ensure_voice)
 @nextcord.slash_command()
 async def play(self, interaction: Interaction, *, query):
 """Plays a file from the local filesystem"""

 source = nextcord.PCMVolumeTransformer(nextcord.FFmpegPCMAudio(query))
 interaction.guild.voice_client.play(source, after=lambda e: print(f"Player error: {e}") if e else None)

 await interaction.send(f"Now playing: {query}")

 @application_checks.application_command_before_invoke(ensure_voice)
 @nextcord.slash_command()
 async def yt(self, interaction: Interaction, *, url):
 """Plays from a URL (almost anything youtube_dl supports)"""

 async with interaction.channel.typing():
 player = await YTDLSource.from_url(url, loop=self.bot.loop)
 interaction.guild.voice_client.play(
 player, after=lambda e: print(f"Player error: {e}") if e else None
 )

 await interaction.send(f"Now playing: {player.title}")

 @application_checks.application_command_before_invoke(ensure_voice)
 @nextcord.slash_command()
 async def stream(self, interaction: Interaction, *, url):
 """Streams from a URL (same as yt, but doesn't predownload)"""

 async with interaction.channel.typing():
 player = await YTDLSource.from_url(url, loop=self.bot.loop, stream=True)
 interaction.voice_client.play(
 player, after=lambda e: print(f"Player error: {e}") if e else None
 )

 await interaction.send(f"Now playing: {player.title}")

def setup(bot):
 bot.add_cog(Music(bot))


2023-01-28T23:16:15Z app[7d3b734a] yyz [info]Exception ignored in: <function at="at" 0x7fa78ea61fc0="0x7fa78ea61fc0">
2023-01-28T23:16:15Z app[7d3b734a] yyz [info]Traceback (most recent call last):
2023-01-28T23:16:15Z app[7d3b734a] yyz [info] File "/usr/local/lib/python3.10/site-packages/nextcord/player.py", line 116, in __del__
2023-01-28T23:16:15Z app[7d3b734a] yyz [info] self.cleanup()
2023-01-28T23:16:15Z app[7d3b734a] yyz [info] File "/usr/local/lib/python3.10/site-packages/nextcord/player.py", line 235, in cleanup
2023-01-28T23:16:15Z app[7d3b734a] yyz [info] self._kill_process()
2023-01-28T23:16:15Z app[7d3b734a] yyz [info] File "/usr/local/lib/python3.10/site-packages/nextcord/player.py", line 191, in _kill_process
2023-01-28T23:16:15Z app[7d3b734a] yyz [info]AttributeError: 'FFmpegA
2023-01-28T23:16:15Z app[7d3b734a] yyz [info]AttributeError: 'FFmpegA
dio' object has no attribute '_process'
2023-01-28T23:16:15Z app[7d3b734a] yyz [info]Ignoring exception in command :
2023-01-28T23:16:15Z app[7d3b734a] yyz [info]Traceback (most recent call last):
2023-01-28T23:16:15Z app[7d3b734a] yyz [info] File "/usr/local/lib/python3.10/site-packages/nextcord/application_command.py", line 863, in invoke_callback_with_hooks
2023-01-28T23:16:15Z app[7d3b734a] yyz [info] await self(interaction, *args, **kwargs)
2023-01-28T23:16:15Z app[7d3b734a] yyz [info] File "/main/cogs/music.py", line 153, in yt
2023-01-28T23:16:15Z app[7d3b734a] yyz [info] player = await YTDLSource.from_url(url, loop=self.bot.loop)
2023-01-28T23:16:15Z app[7d3b734a] yyz [info] File "/main/cogs/music.py", line 71, in from_url 
2023-01-28T23:16:15Z app[7d3b734a] yyz [info] return cls(nextcord.FFmpegAudio(filename, *ffmpeg_options), data=data)
2023-01-28T23:16:15Z app[7d3b734a] yyz [info]
The above exception was the direct cause of the following exception:

re given
2023-01-28T23:16:15Z app[7d3b734a] yyz [info]The above exception was the direct cause of the following exception:
2023-01-28T23:16:15Z app[7d3b734a] yyz [info]nextcord.errors.ApplicationInvokeError: Command raised an exception: TypeError: FFmpegAudio.__init__() takes 2 positional arguments but 3 were given 
2023-01-28T23:16:19Z app[7d3b734a] yyz [info]Exception ignored in: <function at="at" 0x7fa78ea61fc0="0x7fa78ea61fc0">
2023-01-28T23:16:19Z app[7d3b734a] yyz [info]Traceback (most recent call last):
2023-01-28T23:16:19Z app[7d3b734a] yyz [info] File "/usr/local/lib/python3.10/site-packages/nextcord/player.py", line 116, in __del__
2023-01-28T23:16:19Z app[7d3b734a] yyz [info] self.cleanup()
2023-01-28T23:16:19Z app[7d3b734a] yyz [info] File "/usr/local/lib/python3.10/site-packages/nextcord/player.py", line 235, in cleanup
2023-01-28T23:16:19Z app[7d3b734a] yyz [info] self._kill_process()
2023-01-28T23:16:19Z app[7d3b734a] yyz [info] File "/usr/local/lib/python3.10/site-packages/nextcord/player.py", line 191, in _kill_process
2023-01-28T23:16:19Z app[7d3b734a] yyz [info] proc = self._process
2023-01-28T23:16:19Z app[7d3b734a] yyz [info]AttributeError: 'FFmpegAudio' object has no attribute 
'_process'
2023-01-28T23:16:19Z app[7d3b734a] yyz [info]Ignoring exception in command :
2023-01-28T23:16:19Z app[7d3b734a] yyz [info]Traceback (most recent call last):
2023-01-28T23:16:19Z app[7d3b734a] yyz [info] File "/usr/local/lib/python3.10/site-packages/nextcord/application_command.py", line 863, in invoke_callback_with_hooks
2023-01-28T23:16:19Z app[7d3b734a] yyz [info] await self(interaction, *args, **kwargs)
2023-01-28T23:16:19Z app[7d3b734a] yyz [info] File "/main/cogs/music.py", line 153, in yt
2023-01-28T23:16:19Z app[7d3b734a] yyz [info] player = await YTDLSource.from_url(url, loop=self.bot.loop)
2023-01-28T23:16:19Z app[7d3b734a] yyz [info] File "/main/cogs/music.py", line 71, in from_url 
2023-01-28T23:16:19Z app[7d3b734a] yyz [info] return cls(nextcord.FFmpegAudio(filename, *ffmpeg_options), data=data)
2023-01-28T23:16:19Z app[7d3b734a] yyz [info]TypeError: FFmpegAudio.__init__() takes 2 positional arguments but 3 were given
2023-01-28T23:16:19Z app[7d3b734a] yyz [info]The above exception was the direct cause of the following exception:
2023-01-28T23:16:19Z app[7d3b734a] yyz [info]nextcord.errors.ApplicationInvokeError: Command raised an exception: TypeError: FFmpegAudio.__init__() takes 2 positional arguments but 3 were given
</function></function>

Similar posts have been made but their issues were typos in changing 'option' : '-vn' to 'options' : '-vn'. I've combed through for any other errors but I can't find any. I was hoping to see I made a similar mistake, but this is the template I was following from the Nextcord developers and I had no luck :


-
Node.js readable maximize throughput/performance for compute intense readable - Writable doesn't pull data fast enough
31 décembre 2022, par flohallGeneral setup


I developed an application using AWS Lambda node.js 14.
I use a custom
ReadableimplementationFrameCreationStreamthat uses node-canvas to draw images, svgs and more on a canvas. This result is then extracted as a raw image buffer in BGRA. A single image buffer contains 1920 * 1080 * 4 Bytes = 8294400 Bytes 8 MB.
This is then piped tostdinof achild_processrunningffmpeg.
ThehighWaterMarkof myReadableinobjectMode:trueis set to 25 so that the internal buffer can use up to 8 MB * 25 = 200 MB.

All this works fine and also doesn't contain too much RAM. But I noticed after some time, that the performance is not ideally.


Performance not optimal


I have an example input that generates a video of 315 frames. If I set
highWaterMarkto a value above 25 the performance increases to the point, when I set to a value of 315 or above.

For some reason
ffmpegdoesn't start to pull any data untilhighWaterMarkis reached. Obviously thats not what I want.ffmpegshould always consume data if minimum 1 frame is cached in theReadableand if it has finished processing the frame before. And theReadableshould produce more frames as longhighWaterMarkisn't reached or the last frame has been reached. So ideally theReadableand theWriteableare busy all the time.

I found another way to improve the speed. If I add a timeout in the
_read()method of theReadableafter let's say every tenth frame for 100 ms. Then theffmpeg-Writablewill use this timeout to write some frames toffmpeg.

It seems like frames aren't passed to
ffmpegduring frame creation because some node.js main thread is busy ?

The fastest result I have if I increase
highWaterMarkabove the amount of frames - which doesn't work for longer videos as this would make the AWS Lambda RAM explode. And this makes the whole streaming idea useless. Using timeouts always gives me stomach pain. Also depending on the execution on different environments a good fitting timeout might differ. Any ideas ?

FrameCreationStream


import canvas from 'canvas';
import {Readable} from 'stream';
import {IMAGE_STREAM_BUFFER_SIZE, PerformanceUtil, RenderingLibraryError, VideoRendererInput} from 'vm-rendering-backend-commons';
import {AnimationAssets, BufferType, DrawingService, FullAnimationData} from 'vm-rendering-library';

/**
 * This is a proper back pressure compatible implementation of readable for a having a stream to read single frames from.
 * Whenever read() is called a new frame is created and added to the stream.
 * read() will be called internally until options.highWaterMark has been reached.
 * then calling read will be paused until one frame is read from the stream.
 */
export class FrameCreationStream extends Readable {

 drawingService: DrawingService;
 endFrameIndex: number;
 currentFrameIndex: number = 0;
 startFrameIndex: number;
 frameTimer: [number, number];
 readTimer: [number, number];
 fullAnimationData: FullAnimationData;

 constructor(animationAssets: AnimationAssets, fullAnimationData: FullAnimationData, videoRenderingInput: VideoRendererInput, frameTimer: [number, number]) {
 super({highWaterMark: IMAGE_STREAM_BUFFER_SIZE, objectMode: true});

 this.frameTimer = frameTimer;
 this.readTimer = PerformanceUtil.startTimer();

 this.fullAnimationData = fullAnimationData;

 this.startFrameIndex = Math.floor(videoRenderingInput.startFrameId);
 this.currentFrameIndex = this.startFrameIndex;
 this.endFrameIndex = Math.floor(videoRenderingInput.endFrameId);

 this.drawingService = new DrawingService(animationAssets, fullAnimationData, videoRenderingInput, canvas);
 console.time("read");
 }

 /**
 * this method is only overwritten for debugging
 * @param size
 */
 read(size?: number): string | Buffer {

 console.log("read("+size+")");
 const buffer = super.read(size);
 console.log(buffer);
 console.log(buffer?.length);
 if(buffer) {
 console.timeLog("read");
 }
 return buffer;
 }

 // _read() will be called when the stream wants to pull more data in.
 // _read() will be called again after each call to this.push(dataChunk) once the stream is ready to accept more data. https://nodejs.org/api/stream.html#readable_readsize
 // this way it is ensured, that even though this.createImageBuffer() is async, only one frame is created at a time and the order is kept
 _read(): void {
 // as frame numbers are consecutive and unique, we have to draw each frame number (also the first and the last one)
 if (this.currentFrameIndex <= this.endFrameIndex) {
 PerformanceUtil.logTimer(this.readTimer, 'WAIT -> READ\t');
 this.createImageBuffer()
 .then(buffer => this.optionalTimeout(buffer))
 // push means adding a buffered raw frame to the stream
 .then((buffer: Buffer) => {
 this.readTimer = PerformanceUtil.startTimer();
 // the following two frame numbers start with 1 as first value
 const processedFrameNumberOfScene = 1 + this.currentFrameIndex - this.startFrameIndex;
 const totalFrameNumberOfScene = 1 + this.endFrameIndex - this.startFrameIndex;
 // the overall frameId or frameIndex starts with frameId 0
 const processedFrameIndex = this.currentFrameIndex;
 this.currentFrameIndex++;
 this.push(buffer); // nothing besides logging should happen after calling this.push(buffer)
 console.log(processedFrameNumberOfScene + ' of ' + totalFrameNumberOfScene + ' processed - full video frameId: ' + processedFrameIndex + ' - buffered frames: ' + this.readableLength);
 })
 .catch(err => {
 // errors will be finally handled, when subscribing to frameCreation stream in ffmpeg service
 // this log is just generated for tracing errors and if for some reason the handling in ffmpeg service doesn't work
 console.log("createImageBuffer: ", err);
 this.emit("error", err);
 });
 } else {
 // push(null) makes clear that this stream has ended
 this.push(null);
 PerformanceUtil.logTimer(this.frameTimer, 'FRAME_STREAM');
 }
 }

 private optionalTimeout(buffer: Buffer): Promise<buffer> {
 if(this.currentFrameIndex % 10 === 0) {
 return new Promise(resolve => setTimeout(() => resolve(buffer), 140));
 }
 return Promise.resolve(buffer);
 }

 // prevent memory leaks - without this lambda memory will increase with every call
 _destroy(): void {
 this.drawingService.destroyStage();
 }

 /**
 * This creates a raw pixel buffer that contains a single frame of the video drawn by the rendering library
 *
 */
 public async createImageBuffer(): Promise<buffer> {

 const drawTimer = PerformanceUtil.startTimer();
 try {
 await this.drawingService.drawForFrame(this.currentFrameIndex);
 } catch (err: any) {
 throw new RenderingLibraryError(err);
 }

 PerformanceUtil.logTimer(drawTimer, 'DRAW -> FRAME\t');

 const bufferTimer = PerformanceUtil.startTimer();
 // Creates a raw pixel buffer, containing simple binary data
 // the exact same information (BGRA/screen ratio) has to be provided to ffmpeg, because ffmpeg cannot detect format for raw input
 const buffer = await this.drawingService.toBuffer(BufferType.RAW);
 PerformanceUtil.logTimer(bufferTimer, 'CANVAS -> BUFFER');

 return buffer;
 }
}
</buffer></buffer>

FfmpegService


import {ChildProcess, execFile} from 'child_process';
import {Readable} from 'stream';
import {FPS, StageSize} from 'vm-rendering-library';
import {
 FfmpegError,
 LOCAL_MERGE_VIDEOS_TEXT_FILE, LOCAL_SOUND_FILE_PATH,
 LOCAL_VIDEO_FILE_PATH,
 LOCAL_VIDEO_SOUNDLESS_MERGE_FILE_PATH
} from "vm-rendering-backend-commons";

/**
 * This class bundles all ffmpeg usages for rendering one scene.
 * FFmpeg is a console program which can transcode nearly all types of sounds, images and videos from one to another.
 */
export class FfmpegService {

 ffmpegPath: string = null;


 constructor(ffmpegPath: string) {
 this.ffmpegPath = ffmpegPath;
 }

 /**
 * Convert a stream of raw images into an .mp4 video using the command line program ffmpeg.
 *
 * @param inputStream an input stream containing images in raw format BGRA
 * @param stageSize the size of a single frame in pixels (minimum is 2*2)
 * @param outputPath the filepath to write the resulting video to
 */
 public imageToVideo(inputStream: Readable, stageSize: StageSize, outputPath: string): Promise<void> {
 const args: string[] = [
 '-f',
 'rawvideo',
 '-r',
 `${FPS}`,
 '-pix_fmt',
 'bgra',
 '-s',
 `${stageSize.width}x${stageSize.height}`,
 '-i',
 // input "-" means input will be passed via pipe (streamed)
 '-',
 // codec that also QuickTime player can understand
 '-vcodec',
 'libx264',
 '-pix_fmt',
 'yuv420p',
 /*
 * "-movflags faststart":
 * metadata at beginning of file
 * needs more RAM
 * file will be broken, if not finished properly
 * higher application compatibility
 * better for browser streaming
 */
 '-movflags',
 'faststart',
 // "-preset ultrafast", //use this to speed up compression, but quality/compression ratio gets worse
 // don't overwrite an existing file here,
 // but delete file in the beginning of execution index.ts
 // (this is better for local testing believe me)
 outputPath
 ];

 return this.execFfmpegPromise(args, inputStream);
 }

 private execFfmpegPromise(args: string[], inputStream?: Readable): Promise<void> {
 const ffmpegServiceSelf = this;
 return new Promise(function (resolve, reject) {
 const executionProcess: ChildProcess = execFile(ffmpegServiceSelf.ffmpegPath, args, (err) => {
 if (err) {
 reject(new FfmpegError(err));
 } else {
 console.log('ffmpeg finished');
 resolve();
 }
 });
 if (inputStream) {
 // it's important to listen on errors of input stream before piping it into the write stream
 // if we don't do this here, we get an unhandled promise exception for every issue in the input stream
 inputStream.on("error", err => {
 reject(err);
 });
 // don't reject promise here as the error will also be thrown inside execFile and will contain more debugging info
 // this log is just generated for tracing errors and if for some reason the handling in execFile doesn't work
 inputStream.pipe(executionProcess.stdin).on("error", err => console.log("pipe stream: " , err));
 }
 });
 }
}
</void></void>

-
9 Ways to Customise Your Matomo Like a Pro
5 octobre 2022, par ErinMatomo is a feature-rich web analytics platform. As such, it has many layers of depth — core features, extra plug-ins, custom dimensions, reports, extensions and integrations.
Most of the product elements you see can be personalised and customised to your needs with minimal restrictions. However, this breadth of choice can be overlooked by new users.
In this post, we explain how to get the most out of Matomo with custom reports, dashboards, dimensions and even app design.
How to customise your Matomo web analytics
To make major changes to Matomo (e.g., create custom dashboards or install new plugins), you’ll have to be a Matomo Super User (a.k.a. The Admin). Super Users can also grant administrator permissions to others so that more people could customise your Matomo deployment.
Most feature-related customisations (e.g. configuring a custom report, adding custom goal tracking, etc.) can be done by all users.
With the above in mind, here’s how you can tweak Matomo to better serve your website analytics needs :
1. Custom dashboards
Dashboards provide a panorama view of all the collected website statistics. We display different categories of stats and KPIs as separate widgets — a standalone module you can also customise.
On your dashboard, you can change the type, position and number of widgets on display. This is an easy way to create separate dashboard views for different projects, clients or team members. Rather than a one-size-fits-all dashboard, a custom dashboard designed for a specific role or business unit will increase data-driven decision-making and efficiency across the business.
You can create a new dashboard view in a few clicks. Then select a preferred layout — a split-page view or multi columns. Next, populate the new dashboard area with preferred widgets showing :
- SEO website rankings
- Visits, conversions and revenue
- Custom reports
Or code a custom widget area to pull specific website stats or other reporting data you need. Once you are done, arrange everything with our drag-and-drop functionality.
Popular feature use cases
- Personalised website statistics layout for convenient viewing
- Simplified analytics dashboards for the line of business leaders/stakeholders
- Project- or client-specific dashboards for easy report sharing
Read more about customising Matomo dashboards and widget areas.
2. Custom reports
As the name implies, Custom Reports widget allows you to mesh any of the dimensions and metrics collected by Matomo into a custom website traffic analysis. Custom reports save users time by providing specific data needed in one view so there is no need to jump back and forth between multiple reports or toggle through a report to find data.
For each custom report, you can select up to three dimensions and then apply additional quantitative measurements (metrics) to drill down into the data.
For example, if you want to closely observe mobile conversion rates in one market, you can create the following custom report :
- Dimensions : User Type (registered), Device type (mobile), Location (France)
- Metrics : Visits, Conversion Rate, Revenue, Avg. Generation Time.
Custom Report widget is available within Matomo Cloud and as a plugin for Matomo On-Premise.
<script type="text/javascript"><br />
if ('function' === typeof window.playMatomoVideo){<br />
window.playMatomoVideo("custom_reports", "#custom_reports")<br />
} else {<br />
document.addEventListener("DOMContentLoaded", function() { window.playMatomoVideo("custom_reports", "#custom_reports"); });<br />
}<br />
</script>Popular feature use cases
- Campaign-specific reporting to better understand the impact of different promo strategies
- Advanced event tracking for conversion optimization
- Market segmentation reports to analyse different audience cohorts
Read more about creating and analysing Custom Reports.
3. Custom widgets
We realise that our users have different degrees of analytics knowledge. Some love in-depth reporting dimensions and multi-row reporting tables. Others just want to see essential stats.
To delight both the pros and the novice users, we’ve created widgets — reporting sub-modules you can add, delete or rearrange in a few clicks. Essentially, a widget is a slice of a dashboard area you can populate with extra information.
You can add pre-made custom widgets to Matomo or develop your own widget to display custom reports or even external data (e.g., offline sales volume). At the same time, you can also embed Matomo widgets into other applications (e.g., a website CMS or corporate portal).
Popular feature use cases
- Display main goals (e.g., new trial sign-ups) on the main dashboard for greater visibility
- Highlight cost-per-conversion reporting by combining goals and conversion data to keep your budgets in check
- Run omnichannel eCommerce analytics (with embedded offline sales data) to get a 360-degree view into your operations
Read more about creating widgets in Matomo (beginner’s guide).
4. Custom dimensions
Dimensions describe the characteristics of reported data. Think of them as “filters” — a means to organise website analytics data by a certain parameter such as “Browser”, “Country”, “Device Type”, “User Type” and many more.
Custom Dimensions come in handy for all sorts of segmentation reports. For example, comparing conversion rates between registered and guest users. Or tracking revenue by device type and location.
For convenience, we’ve grouped Custom Dimensions in two categories :
Visit dimensions. These associate metadata about a user with Visitor profiles — a summary of different knowledge you have about your audience. Reports for Visit scoped custom dimensions are available in the Visitors section of your dashboard.
Action dimensions. These segment users by specific actions tracked by Matomo such as pageviews, events completion, downloads, form clicks, etc. When configuring Custom Dimensions, you can select among pre-defined action types or code extra action dimensions. Action scoped custom dimensions are available in the Behaviours section of Matomo.
Depending on your Matomo version, you can apply 5 – 15 custom dimensions to reports.
Important : Since you can’t delete dimensions (only deactivate them), think about your use case first. Custom Dimensions each have their own dedicated reports page on your Matomo dashboard.
Popular custom dimension use cases among users :
- Segmenting reports by users’ screen resolution size to understand how your website performs on different devices
- Monitor conversion rates for different page types to determine your best-performing assets
Read more about creating, tracking and managing Custom Dimensions.
5. Custom scheduled reports
Manually sending reports can be time consuming, especially if you have multiple clients or provide reports to numerous stakeholders. Custom scheduled reports remove this manual process to improve efficiency and ensure timely distribution of data to relevant users.
Any report in Matomo (default or custom) can be shared with others by email as a PDF file, HTML content or as an attached CSV document.
You can customise which data you want to send to different people — your colleagues, upper management, clients or other company divisions. Then set up the frequency of email dispatches and Matomo will do the rest.
Auto-scheduling an email report is easy. Name your report, select a Segment (aka custom or standard report), pick time, file format and sender.
You can also share links to Matomo reports as text messages, if you are using ASPSMS or Clockwork SMS.
Popular feature use cases
- Convenient stakeholder reporting on key website KPIs
- Automated client updates to keep clients informed and reduce workload
- Easy data downloads for doing custom analysis with business intelligence tools
Read more about email reporting features in Matomo.
6. Custom alerts
Custom Alerts is a Matomo plugin for keeping you updated on the most important analytics events. Unlike Custom Reports, which provide a complete or segmented analytics snapshot, alerts are better suited for tracking individual events. For example, significant traffic increases from a specific channel, new 404 pages or major goal achievement (e.g., hitting 1,000 sales in a week).
Custom Alerts are a convenient way to keep your finger on the pulse of your site so you can quickly remedy an issue or get updated on reaching a crucial KPI promptly. You can receive custom alerts via email or text message in a matter of minutes.
To avoid flooding your inbox with alerts, we recommend reserving Custom Alerts for a select few use cases (3 to 5) and schedule custom Email Reports to receive general web page analytics.
Popular custom alerts use cases among users :
- Monitor sudden drops in revenue to investigate the cause behind them and solve any issues promptly
- Get notified of traffic spikes or sudden dips to better manage your website’s technical performance
Read more about creating and managing Custom Alerts.
7. Goals
Goals feature helps you better understand how your website performs on certain business objectives such as lead generation, online sales or content discovery. A goal is a quantifiable action you want to measure (e.g., a specific page visit, form submission or a file download).
When combined together, Goals make up your sales funnel — a series of specific actions you expect users to complete in order to convert.
Goals-setting and Funnel Analytics are a powerful, customisable combo for understanding how people navigate your website ; what makes them take action or, on the contrary, lose interest and bounce off.
On Matomo, you can simultaneously track multiple goals, monitor multiple conversions per one visit (e.g., when one user requests two content downloads) and assign revenue targets to specific goals.
<script type="text/javascript"><br />
if ('function' === typeof window.playMatomoVideo){<br />
window.playMatomoVideo("goals", "#goals")<br />
} else {<br />
document.addEventListener("DOMContentLoaded", function() { window.playMatomoVideo("goals", "#goals"); });<br />
}<br />
</script>Separately, Matomo Cloud users also get access to a premium Funnels feature and Multi Channel Conversion Attribution. On-Premises Matomo users can get both as paid plugins via our Marketplace.
Popular goal tracking use cases among users :
- Tracking newsletter subscription to maximise subscriber growth
- Conversion tracking for gated content (e.g., eBooks) to understand how each asset performs
- Analysing the volume of job applications per post to better interpret your HR marketing performance
Read more about creating and managing Goals in Matomo.
8. Themes
Want to give your Matomo app a distinctive visual flair ? Pick a new free theme for your On-Premises installation. Minimalistic, dark or classic — our community created six different looks that other Matomo users can download and install in a few clicks.
If you have some HTML/CSS/JS knowledge, you can also design your own Matomo theme. Since Matomo is an open-source project, we don’t restrict interface customisation and always welcome creativity from our users.
Read more about designing your own Matomo theme (developer documentation).
9. White labelling
Matomo is one of the few website analytics tools to support white labelling. White labelling means that you can distribute our product to others under your brand.
For example, as a web design agency, you can delight customers with pre-installed GDPR-friendly website analytics. Marketing services providers, in turn, can present their clients with embedded reporting widgets, robust funnel analytics and 100% unsampled data.
Apart from selecting a custom theme, you can also align Matomo with your brand by :
- Customising product name
- Using custom header/font colours
- Change your tracking endpoint
- Remove links to Matomo.org
To streamline Matomo customisation and set-up, we developed a White Label plug-in. It provides a convenient set of controls for changing your Matomo deployment and distributing access rights to other users or sharing embedded Matomo widgets).
Read more about white labelling Matomo.
Learning more about Matomo
Matomo has an ever-growing list of features, ranging from standard website tracking controls to unique conversion rate optimisation tools (heatmaps, media analytics, user cohorts and more).
To learn more about Matomo features you can check our free video web analytics training series where we cover the basics. For feature-specific tips, tricks and configurations, browse our video content or written guides.
Syndiquer tout le site
